diff options
Diffstat (limited to 'stdlib')
83 files changed, 805 insertions, 825 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)))))) ) diff --git a/stdlib/test/test/lux.lux b/stdlib/test/test/lux.lux index 788085db4..1f0a6e115 100644 --- a/stdlib/test/test/lux.lux +++ b/stdlib/test/test/lux.lux @@ -26,7 +26,7 @@ (not (is? x y))) )))) -(do-template [category rand-gen inc dec even? odd? = < >] +(do-template [category rand-gen even? odd? = < >] [(context: (format "[" category "] " "Moving up-down or down-up should result in same value.") (<| (times +100) (do @ @@ -52,8 +52,8 @@ (and (|> value inc even?) (|> value dec even?)))))))] - ["Nat" r.nat n/inc n/dec n/even? n/odd? n/= n/< n/>] - ["Int" r.int i/inc i/dec i/even? i/odd? i/= i/< i/>] + ["Nat" r.nat n/even? n/odd? n/= n/< n/>] + ["Int" r.int i/even? i/odd? i/= i/< i/>] ) (do-template [category rand-gen = < > <= >= min max] @@ -86,7 +86,7 @@ ["Deg" r.deg d/= d/< d/> d/<= d/>= d/min d/max] ) -(do-template [category rand-gen = + - * / <%> > <0> <1> <factor> %x <cap> <prep>] +(do-template [category rand-gen = + - * / <%> > <0> <1> <factor> <cap> <prep>] [(context: (format "[" category "] " "Additive identity") (<| (times +100) (do @ @@ -136,10 +136,10 @@ (|> x' (/ y) (* y) (= x')))) ))))] - ["Nat" r.nat n/= n/+ n/- n/* n// n/% n/> +0 +1 +1000000 %n (n/% +1000) id] - ["Int" r.int i/= i/+ i/- i/* i// i/% i/> 0 1 1000000 %i (i/% 1000) id] - ["Frac" r.frac f/= f/+ f/- f/* f// f/% f/> 0.0 1.0 1000000.0 %r id math.floor] - ["Deg" r.deg d/= d/+ d/- d/* d// d/% d/> .0 (:! Deg -1) (:! Deg -1) %f id id] + ["Nat" r.nat n/= n/+ n/- n/* n// n/% n/> +0 +1 +1_000_000 (n/% +1_000) id] + ["Int" r.int i/= i/+ i/- i/* i// i/% i/> 0 1 1_000_000 (i/% 1_000) id] + ["Frac" r.frac f/= f/+ f/- f/* f// f/% f/> 0.0 1.0 1_000_000.0 id math.floor] + ["Deg" r.deg d/= d/+ d/- d/* d// d/% d/> .0 (.deg -1) (.deg -1) id id] ) (def: frac-deg @@ -147,7 +147,7 @@ (|> r.deg (:: r.Functor<Random> map (|>> (:! Nat) (bit.left-shift +11) (bit.right-shift +11) (:! Deg))))) -(do-template [category rand-gen -> <- = <cap> %a %z] +(do-template [category rand-gen -> <- = <cap>] [(context: (format "[" category "] " "Numeric conversions") (<| (times +100) (do @ @@ -156,11 +156,11 @@ (test "" (|> value -> <- (= value))))))] - ["Int->Nat" r.int int-to-nat nat-to-int i/= (i/% 1000000) %i %n] - ["Nat->Int" r.nat nat-to-int int-to-nat n/= (n/% +1000000) %n %i] - ["Int->Frac" r.int int-to-frac frac-to-int i/= (i/% 1000000) %i %r] - ["Frac->Int" r.frac frac-to-int int-to-frac f/= math.floor %r %i] - ["Deg->Frac" frac-deg deg-to-frac frac-to-deg d/= id %d %r] + ["Int->Nat" r.int .nat .int i/= (i/% 1_000_000)] + ["Nat->Int" r.nat .int .nat n/= (n/% +1_000_000)] + ["Int->Frac" r.int int-to-frac frac-to-int i/= (i/% 1_000_000)] + ["Frac->Int" r.frac frac-to-int int-to-frac f/= math.floor] + ["Deg->Frac" frac-deg deg-to-frac frac-to-deg d/= id] ) (context: "Simple macros and constructs" @@ -170,7 +170,7 @@ (loop [counter 0 value 1] (if (i/< 3 counter) - (recur (i/inc counter) (i/* 10 value)) + (recur (inc counter) (i/* 10 value)) value)))) (test "Can create lists easily through macros." diff --git a/stdlib/test/test/lux/concurrency/atom.lux b/stdlib/test/test/lux/concurrency/atom.lux index 9063af2e7..a4856252a 100644 --- a/stdlib/test/test/lux/concurrency/atom.lux +++ b/stdlib/test/test/lux/concurrency/atom.lux @@ -25,8 +25,8 @@ (n/= swap-value (io.run (&.read box))))) (test "Can update the value of an atom." - (exec (io.run (&.update n/inc box)) - (n/= (n/inc swap-value) (io.run (&.read box))))) + (exec (io.run (&.update inc box)) + (n/= (inc swap-value) (io.run (&.read box))))) (test "Can immediately set the value of an atom." (exec (io.run (&.write set-value box)) diff --git a/stdlib/test/test/lux/concurrency/frp.lux b/stdlib/test/test/lux/concurrency/frp.lux index 9630016e4..527fafb36 100644 --- a/stdlib/test/test/lux/concurrency/frp.lux +++ b/stdlib/test/test/lux/concurrency/frp.lux @@ -79,7 +79,7 @@ [output (promise.future (do io.Monad<IO> [#let [inputs (: (Channel Int) (frp.channel [])) - mapped (:: frp.Functor<Channel> map i/inc inputs)] + mapped (:: frp.Functor<Channel> map inc inputs)] output (read! mapped) _ (write! (list 0 1 2 3 4 5) inputs)] (wrap output))) @@ -96,7 +96,7 @@ >a< (: (Channel Int) (frp.channel []))] output (read! (let [(^open) frp.Apply<Channel>] (apply >f< >a<))) - _ (write! (list i/inc) >f<) + _ (write! (list inc) >f<) _ (write! (list 12345) >a<)] (wrap output))) _ (promise.wait +100) @@ -108,7 +108,7 @@ (wrap (do promise.Monad<Promise> [output (promise.future (read! (do frp.Monad<Channel> - [f (frp.from-promise (promise.delay +100 i/inc)) + [f (frp.from-promise (promise.delay +100 inc)) a (frp.from-promise (promise.delay +200 12345))] (frp.from-promise (promise.delay +300 (f a)))))) _ (promise.wait +700) diff --git a/stdlib/test/test/lux/concurrency/semaphore.lux b/stdlib/test/test/lux/concurrency/semaphore.lux index a41f06096..af025dbb5 100644 --- a/stdlib/test/test/lux/concurrency/semaphore.lux +++ b/stdlib/test/test/lux/concurrency/semaphore.lux @@ -18,7 +18,7 @@ (if (n/> +0 steps) (do promise.Monad<Promise> [_ (/.wait semaphore)] - (recur (n/dec steps))) + (recur (dec steps))) (:: promise.Monad<Promise> wrap [])))) (context: "Semaphore." @@ -34,7 +34,7 @@ (let [semaphore (/.semaphore open-positions)] (wrap (do promise.Monad<Promise> [result (<| (promise.time-out +100) - (wait-many-times (n/inc open-positions) semaphore))] + (wait-many-times (inc open-positions) semaphore))] (assert "Waiting on a semaphore more than the number of open positions blocks the process." (case result (#.Some _) @@ -50,7 +50,7 @@ (do @ [_ (/.wait semaphore) _ (/.signal semaphore)] - (recur (n/dec steps))) + (recur (dec steps))) (wrap []))))] (assert "Signaling a semaphore replenishes its open positions." true)))) @@ -122,7 +122,7 @@ resource (atom.atom "")] ($_ seq (wrap (do promise.Monad<Promise> - [#let [ids (list.n/range +0 (n/dec limit)) + [#let [ids (list.n/range +0 (dec limit)) waiters (list/map (function (_ id) (let [process (waiter resource barrier id)] (exec (io.run (atom.update (|>> (format "_")) resource)) diff --git a/stdlib/test/test/lux/concurrency/stm.lux b/stdlib/test/test/lux/concurrency/stm.lux index bf562c0fa..9f3c5bd7e 100644 --- a/stdlib/test/test/lux/concurrency/stm.lux +++ b/stdlib/test/test/lux/concurrency/stm.lux @@ -25,46 +25,49 @@ channel)] (wrap output))) -(def: iterations/processes Int 100) +(def: iterations-per-process Nat +100) (context: "STM" ($_ seq (wrap (do promise.Monad<Promise> - [output (&.commit (&.read (&.var 0)))] + [output (&.commit (&.read (&.var +0)))] (assert "Can read STM vars." - (i/= 0 output)))) + (n/= +0 output)))) (wrap (do promise.Monad<Promise> - [#let [_var (&.var 0)] + [#let [_var (&.var +0)] output (&.commit (do &.Monad<STM> - [_ (&.write 5 _var)] + [_ (&.write +5 _var)] (&.read _var)))] (assert "Can write STM vars." - (i/= 5 output)))) + (n/= +5 output)))) (wrap (do promise.Monad<Promise> - [#let [_var (&.var 5)] + [#let [_var (&.var +5)] output (&.commit (do &.Monad<STM> - [_ (&.update (i/* 3) _var)] + [_ (&.update (n/* +3) _var)] (&.read _var)))] (assert "Can update STM vars." - (i/= 15 output)))) + (n/= +15 output)))) (wrap (do promise.Monad<Promise> - [#let [_var (&.var 0) + [#let [_var (&.var +0) changes (io.run (read! (io.run (&.follow _var))))] - _ (&.commit (&.write 5 _var)) - _ (&.commit (&.update (i/* 3) _var)) + _ (&.commit (&.write +5 _var)) + _ (&.commit (&.update (n/* +3) _var)) changes (promise.future (atom.read changes))] (assert "Can follow all the changes to STM vars." - (:: (list.Eq<List> number.Eq<Int>) = - (list 5 15) + (:: (list.Eq<List> number.Eq<Nat>) = + (list +5 +15) (list.reverse changes))))) - (wrap (let [_concurrency-var (&.var 0)] + (wrap (let [_concurrency-var (&.var +0)] (do promise.Monad<Promise> - [_ (M.seq @ - (map (function (_ _) - (M.map @ (function (_ _) (&.commit (&.update i/inc _concurrency-var))) - (list.i/range 1 iterations/processes))) - (list.i/range 1 (nat-to-int promise.parallelism-level)))) + [_ (|> promise.parallelism + (list.n/range +1) + (map (function (_ _) + (|> iterations-per-process + (list.n/range +1) + (M.map @ (function (_ _) (&.commit (&.update inc _concurrency-var))))))) + (M.seq @)) last-val (&.commit (&.read _concurrency-var))] (assert "Can modify STM vars concurrently from multiple threads." - (i/= (i/* iterations/processes (nat-to-int promise.parallelism-level)) - last-val))))))) + (|> promise.parallelism + (n/* iterations-per-process) + (n/= last-val)))))))) diff --git a/stdlib/test/test/lux/control/continuation.lux b/stdlib/test/test/lux/control/continuation.lux index 7f9ff00d9..ea43b511d 100644 --- a/stdlib/test/test/lux/control/continuation.lux +++ b/stdlib/test/test/lux/control/continuation.lux @@ -23,16 +23,16 @@ (n/= sample (&.run (&/wrap sample)))) (test "Can use functor." - (n/= (n/inc sample) (&.run (&/map n/inc (&/wrap sample))))) + (n/= (inc sample) (&.run (&/map inc (&/wrap sample))))) (test "Can use apply." - (n/= (n/inc sample) (&.run (&/apply (&/wrap n/inc) (&/wrap sample))))) + (n/= (inc sample) (&.run (&/apply (&/wrap inc) (&/wrap sample))))) (test "Can use monad." - (n/= (n/inc sample) (&.run (do &.Monad<Cont> - [func (wrap n/inc) - arg (wrap sample)] - (wrap (func arg)))))) + (n/= (inc sample) (&.run (do &.Monad<Cont> + [func (wrap inc) + arg (wrap sample)] + (wrap (func arg)))))) (test "Can use the current-continuation as a escape hatch." (n/= (n/* +2 sample) @@ -52,7 +52,7 @@ (&.run (do &.Monad<Cont> [[restart [output idx]] (&.portal [sample +0])] (if (n/< +10 idx) - (restart [(n/+ +10 output) (n/inc idx)]) + (restart [(n/+ +10 output) (inc idx)]) (wrap output)))))) (test "Can use delimited continuations with shifting." diff --git a/stdlib/test/test/lux/control/pipe.lux b/stdlib/test/test/lux/control/pipe.lux index 79e920468..d159cfeb9 100644 --- a/stdlib/test/test/lux/control/pipe.lux +++ b/stdlib/test/test/lux/control/pipe.lux @@ -17,7 +17,7 @@ (|> 20 (i/* 3) (i/+ 4) - (new> 0 i/inc) + (new> 0 inc) (i/= 1))) (test "Can give names to piped values within a pipeline's scope." @@ -44,7 +44,7 @@ (test "Can loop within pipelines." (|> 1 (loop> [(i/< 10)] - [i/inc]) + [inc]) (i/= 10))) (test "Can use monads within pipelines." @@ -52,7 +52,7 @@ (do> Monad<Identity> [(i/* 3)] [(i/+ 4)] - [i/inc]) + [inc]) (i/= 20))) (test "Can pattern-match against piped values." diff --git a/stdlib/test/test/lux/control/reader.lux b/stdlib/test/test/lux/control/reader.lux index f84d8d16f..eba19b47b 100644 --- a/stdlib/test/test/lux/control/reader.lux +++ b/stdlib/test/test/lux/control/reader.lux @@ -15,7 +15,7 @@ ($_ seq (test "" (i/= 123 (&.run 123 &.ask))) (test "" (i/= 246 (&.run 123 (&.local (i/* 2) &.ask)))) - (test "" (i/= 134 (&.run 123 (&/map i/inc (i/+ 10))))) + (test "" (i/= 134 (&.run 123 (&/map inc (i/+ 10))))) (test "" (i/= 10 (&.run 123 (&/wrap 10)))) (test "" (i/= 30 (&.run 123 (&/apply (&/wrap (i/+ 10)) (&/wrap 20))))) (test "" (i/= 30 (&.run 123 (do &.Monad<Reader> diff --git a/stdlib/test/test/lux/control/region.lux b/stdlib/test/test/lux/control/region.lux index 429359057..a266218f9 100644 --- a/stdlib/test/test/lux/control/region.lux +++ b/stdlib/test/test/lux/control/region.lux @@ -35,7 +35,7 @@ #let [@@ @ count-clean-up (function (_ value) (do @ - [_ (thread.update n/inc clean-up-counter)] + [_ (thread.update inc clean-up-counter)] (wrap (#e.Success []))))] outcome (/.run @ (do (/.Monad<Region> @) @@ -53,7 +53,7 @@ #let [@@ @ count-clean-up (function (_ value) (do @ - [_ (thread.update n/inc clean-up-counter)] + [_ (thread.update inc clean-up-counter)] (wrap (#e.Success []))))] outcome (/.run @ (do (/.Monad<Region> @) @@ -72,7 +72,7 @@ #let [@@ @ count-clean-up (function (_ value) (do @ - [_ (thread.update n/inc clean-up-counter)] + [_ (thread.update inc clean-up-counter)] (wrap (: (Error Top) (ex.throw oops [])))))] outcome (/.run @ (do (/.Monad<Region> @) diff --git a/stdlib/test/test/lux/control/state.lux b/stdlib/test/test/lux/control/state.lux index 33a318a2f..381a40b79 100644 --- a/stdlib/test/test/lux/control/state.lux +++ b/stdlib/test/test/lux/control/state.lux @@ -38,8 +38,8 @@ [_ (&.update (n/* value))] &.get))) (test "Can use the state." - (with-conditions [state (n/inc state)] - (&.use n/inc))) + (with-conditions [state (inc state)] + (&.use inc))) (test "Can use a temporary (local) state." (with-conditions [state (n/* value state)] (&.local (n/* value) @@ -56,8 +56,8 @@ (^open "&/") &.Monad<State>]] ($_ seq (test "Can use functor." - (with-conditions [state (n/inc state)] - (&/map n/inc &.get))) + (with-conditions [state (inc state)] + (&/map inc &.get))) (test "Can use apply." (and (with-conditions [state value] (&/wrap value)) @@ -103,12 +103,12 @@ (wrap (n/< limit state)))]] ($_ seq (test "'while' will only execute if the condition is true." - (|> (&.while condition (&.update n/inc)) + (|> (&.while condition (&.update inc)) (&.run +0) (case> [state' output'] (n/= limit state')))) (test "'do-while' will execute at least once." - (|> (&.do-while condition (&.update n/inc)) + (|> (&.do-while condition (&.update inc)) (&.run +0) (case> [state' output'] (or (n/= limit state') diff --git a/stdlib/test/test/lux/control/writer.lux b/stdlib/test/test/lux/control/writer.lux index 09f37a957..49335de0d 100644 --- a/stdlib/test/test/lux/control/writer.lux +++ b/stdlib/test/test/lux/control/writer.lux @@ -14,7 +14,7 @@ (^open "&/") (&.Apply<Writer> text.Monoid<Text>)] ($_ seq (test "Functor respects Writer." - (i/= 11 (product.right (&/map i/inc ["" 10])))) + (i/= 11 (product.right (&/map inc ["" 10])))) (test "Apply respects Writer." (and (i/= 20 (product.right (&/wrap 20))) diff --git a/stdlib/test/test/lux/data/bit.lux b/stdlib/test/test/lux/data/bit.lux index 1b8110d31..9008f89cf 100644 --- a/stdlib/test/test/lux/data/bit.lux +++ b/stdlib/test/test/lux/data/bit.lux @@ -14,7 +14,7 @@ idx (:: @ map (n/% &.width) r.nat)] ($_ seq (test "Clearing and settings bits should alter the count." - (and (n/= (n/dec (&.count (&.set idx pattern))) + (and (n/= (dec (&.count (&.set idx pattern))) (&.count (&.clear idx pattern))) (|> (&.count pattern) (n/- (&.count (&.clear idx pattern))) @@ -66,7 +66,7 @@ (&.rotate-right &.width) (n/= pattern)))) (test "Shift right respect the sign of ints." - (let [value (nat-to-int pattern)] + (let [value (.int pattern)] (if (i/< 0 value) (i/< 0 (&.arithmetic-right-shift idx value)) (i/>= 0 (&.arithmetic-right-shift idx value))))) diff --git a/stdlib/test/test/lux/data/coll/array.lux b/stdlib/test/test/lux/data/coll/array.lux index 729f84221..125694cc7 100644 --- a/stdlib/test/test/lux/data/coll/array.lux +++ b/stdlib/test/test/lux/data/coll/array.lux @@ -39,7 +39,7 @@ (exec (:: @.Fold<Array> fold (function (_ x idx) (exec (@.write idx x manual-copy) - (n/inc idx))) + (inc idx))) +0 original) (:: (@.Eq<Array> number.Eq<Nat>) = original manual-copy))) @@ -109,8 +109,8 @@ (and (= array copy) (not (is? array copy))))) (test "Functor should go over all available array elements." - (let [there (map n/inc array) - back-again (map n/dec there)] + (let [there (map inc array) + back-again (map dec there)] (and (not (= array there)) (= array back-again))))))))) diff --git a/stdlib/test/test/lux/data/coll/bits.lux b/stdlib/test/test/lux/data/coll/bits.lux index d33fa61b1..f416f9866 100644 --- a/stdlib/test/test/lux/data/coll/bits.lux +++ b/stdlib/test/test/lux/data/coll/bits.lux @@ -51,7 +51,7 @@ /.empty)) (/.intersects? (/.set idx /.empty) (/.set idx /.empty)) - (not (/.intersects? (/.set (n/inc idx) /.empty) + (not (/.intersects? (/.set (inc idx) /.empty) (/.set idx /.empty))))) (test "Cannot intersect with one's opposite." (not (/.intersects? sample (/.not sample)))) diff --git a/stdlib/test/test/lux/data/coll/dictionary/unordered.lux b/stdlib/test/test/lux/data/coll/dictionary/unordered.lux index 8c6ea275e..f0224a015 100644 --- a/stdlib/test/test/lux/data/coll/dictionary/unordered.lux +++ b/stdlib/test/test/lux/data/coll/dictionary/unordered.lux @@ -74,10 +74,10 @@ (test "Should be possible to update values via their keys." (let [base (&.put non-key test-val dict) - updt (&.update non-key n/inc base)] + updt (&.update non-key inc base)] (case [(&.get non-key base) (&.get non-key updt)] [(#.Some x) (#.Some y)] - (n/= (n/inc x) y) + (n/= (inc x) y) _ false))) @@ -85,8 +85,8 @@ (test "Additions and removals to a Dict should affect its size." (let [plus (&.put non-key test-val dict) base (&.remove non-key plus)] - (and (n/= (n/inc (&.size dict)) (&.size plus)) - (n/= (n/dec (&.size plus)) (&.size base))))) + (and (n/= (inc (&.size dict)) (&.size plus)) + (n/= (dec (&.size plus)) (&.size base))))) (test "A Dict should equal itself & going to<->from lists shouldn't change that." (let [(^open) (&.Eq<Dict> number.Eq<Nat>)] @@ -99,7 +99,7 @@ (test "If you merge, and the second dict has overlapping keys, it should overwrite yours." (let [dict' (|> dict &.entries - (list/map (function (_ [k v]) [k (n/inc v)])) + (list/map (function (_ [k v]) [k (inc v)])) (&.from-list number.Hash<Nat>)) (^open) (&.Eq<Dict> number.Eq<Nat>)] (= dict' (&.merge dict' dict)))) diff --git a/stdlib/test/test/lux/data/coll/list.lux b/stdlib/test/test/lux/data/coll/list.lux index 578b652da..73eb25d85 100644 --- a/stdlib/test/test/lux/data/coll/list.lux +++ b/stdlib/test/test/lux/data/coll/list.lux @@ -89,8 +89,8 @@ (test "Functor should go over every element of the list." (let [(^open) &.Functor<List> - there (map n/inc sample) - back-again (map n/dec there)] + there (map inc sample) + back-again (map dec there)] (and (not (= sample there)) (= sample back-again)))) @@ -154,7 +154,7 @@ (and (n/= size (&.size indices)) (= indices (&.sort n/< indices)) - (&.every? (n/= (n/dec size)) + (&.every? (n/= (dec size)) (&.zip2-with n/+ indices (&.sort n/> indices))) @@ -163,7 +163,7 @@ (test "The 'interpose' function places a value between every member of a list." (let [(^open) &.Functor<List> sample+ (&.interpose separator sample)] - (and (n/= (|> size (n/* +2) n/dec) + (and (n/= (|> size (n/* +2) dec) (&.size sample+)) (|> sample+ &.as-pairs (map product.right) (&.every? (n/= separator)))))) @@ -179,8 +179,8 @@ (let [(^open) &.Monad<List> (^open) &.Apply<List>] (and (= (list separator) (wrap separator)) - (= (map n/inc sample) - (apply (wrap n/inc) sample))))) + (= (map inc sample) + (apply (wrap inc) sample))))) (test "List concatenation is a monad." (let [(^open) &.Monad<List> @@ -200,8 +200,8 @@ (&.every? (bool.complement n/even?) sample)))) (test "You can iteratively construct a list, generating values until you're done." - (= (&.n/range +0 (n/dec size)) - (&.iterate (function (_ n) (if (n/< size n) (#.Some (n/inc n)) #.None)) + (= (&.n/range +0 (dec size)) + (&.iterate (function (_ n) (if (n/< size n) (#.Some (inc n)) #.None)) +0))) (test "Can enumerate all elements in a list." @@ -216,8 +216,8 @@ (list/= (&.n/range from to) (&.reverse (&.n/range to from)))) (let [(^open "list/") (&.Eq<List> number.Eq<Int>) - from (nat-to-int from) - to (nat-to-int to)] + from (.int from) + to (.int to)] (list/= (&.i/range from to) (&.reverse (&.i/range to from)))))) )))) diff --git a/stdlib/test/test/lux/data/coll/queue.lux b/stdlib/test/test/lux/data/coll/queue.lux index 34330838b..7edcbf9b4 100644 --- a/stdlib/test/test/lux/data/coll/queue.lux +++ b/stdlib/test/test/lux/data/coll/queue.lux @@ -21,9 +21,9 @@ (n/= size (&.size sample)))) (test "Enqueueing and dequeing affects the size of queues." - (and (n/= (n/inc size) (&.size (&.push non-member sample))) + (and (n/= (inc size) (&.size (&.push non-member sample))) (or (&.empty? sample) - (n/= (n/dec size) (&.size (&.pop sample)))) + (n/= (dec size) (&.size (&.pop sample)))) (n/= size (&.size (&.pop (&.push non-member sample)))))) (test "Transforming to/from list can't change the queue." diff --git a/stdlib/test/test/lux/data/coll/queue/priority.lux b/stdlib/test/test/lux/data/coll/queue/priority.lux index 2ccb58ec4..38527523a 100644 --- a/stdlib/test/test/lux/data/coll/queue/priority.lux +++ b/stdlib/test/test/lux/data/coll/queue/priority.lux @@ -31,10 +31,10 @@ (n/= size (&.size sample))) (test "Enqueueing and dequeing affects the size of queues." - (and (n/= (n/inc size) + (and (n/= (inc size) (&.size (&.push non-member-priority non-member sample))) (or (n/= +0 (&.size sample)) - (n/= (n/dec size) + (n/= (dec size) (&.size (&.pop sample)))))) (test "I can query whether an element belongs to a queue." diff --git a/stdlib/test/test/lux/data/coll/sequence.lux b/stdlib/test/test/lux/data/coll/sequence.lux index e1d561fb7..024e91c6b 100644 --- a/stdlib/test/test/lux/data/coll/sequence.lux +++ b/stdlib/test/test/lux/data/coll/sequence.lux @@ -30,8 +30,8 @@ (n/= size (&.size sample)))) (test "Can add and remove elements to sequences." - (and (n/= (n/inc size) (&.size (&.add non-member sample))) - (n/= (n/dec size) (&.size (&.pop sample))))) + (and (n/= (inc size) (&.size (&.add non-member sample))) + (n/= (dec size) (&.size (&.pop sample))))) (test "Can put and get elements into sequences." (|> sample @@ -42,9 +42,9 @@ (test "Can update elements of sequences." (|> sample - (&.put idx non-member) (&.update idx n/inc) + (&.put idx non-member) (&.update idx inc) (&.nth idx) maybe.assume - (n/= (n/inc non-member)))) + (n/= (inc non-member)))) (test "Can safely transform to/from lists." (|> sample &.to-list &.from-list (&/= sample))) @@ -58,14 +58,14 @@ (&/fold n/+ +0 sample))) (test "Functor goes over every element." - (let [there (&/map n/inc sample) - back-again (&/map n/dec there)] + (let [there (&/map inc sample) + back-again (&/map dec there)] (and (not (&/= sample there)) (&/= sample back-again)))) (test "Apply allows you to create singleton sequences, and apply sequences of functions to sequences of values." (and (&/= (&.sequence non-member) (&/wrap non-member)) - (&/= (&/map n/inc sample) (&/apply (&/wrap n/inc) sample)))) + (&/= (&/map inc sample) (&/apply (&/wrap inc) sample)))) (test "Sequence concatenation is a monad." (&/= (&/compose sample other-sample) diff --git a/stdlib/test/test/lux/data/coll/stack.lux b/stdlib/test/test/lux/data/coll/stack.lux index 216c1a8c5..9a5b1b438 100644 --- a/stdlib/test/test/lux/data/coll/stack.lux +++ b/stdlib/test/test/lux/data/coll/stack.lux @@ -32,14 +32,14 @@ (test "Popping empty stacks doesn't change anything. But, if they're non-empty, the top of the stack is removed." (let [sample' (&.pop sample)] - (or (n/= (&.size sample) (n/inc (&.size sample'))) + (or (n/= (&.size sample) (inc (&.size sample'))) (and (&.empty? sample) (&.empty? sample'))) )) (test "Pushing onto a stack always increases it by 1, adding a new value at the top." (and (is? sample (&.pop (&.push new-top sample))) - (n/= (n/inc (&.size sample)) (&.size (&.push new-top sample))) + (n/= (inc (&.size sample)) (&.size (&.push new-top sample))) (|> (&.push new-top sample) &.peek maybe.assume (is? new-top)))) )))) diff --git a/stdlib/test/test/lux/data/coll/stream.lux b/stdlib/test/test/lux/data/coll/stream.lux index cbdfcab49..9431e2a46 100644 --- a/stdlib/test/test/lux/data/coll/stream.lux +++ b/stdlib/test/test/lux/data/coll/stream.lux @@ -22,28 +22,28 @@ cycle-seed (r.list size r.nat) cycle-sample-idx (|> r.nat (:: @ map (n/% +1000))) #let [(^open "List/") (list.Eq<List> number.Eq<Nat>) - sample0 (&.iterate n/inc +0) - sample1 (&.iterate n/inc offset)]] + sample0 (&.iterate inc +0) + sample1 (&.iterate inc offset)]] ($_ seq (test "Can move along a stream and take slices off it." - (and (and (List/= (list.n/range +0 (n/dec size)) + (and (and (List/= (list.n/range +0 (dec size)) (&.take size sample0)) - (List/= (list.n/range offset (n/dec (n/+ offset size))) + (List/= (list.n/range offset (dec (n/+ offset size))) (&.take size (&.drop offset sample0))) (let [[drops takes] (&.split size sample0)] - (and (List/= (list.n/range +0 (n/dec size)) + (and (List/= (list.n/range +0 (dec size)) drops) - (List/= (list.n/range size (n/dec (n/* +2 size))) + (List/= (list.n/range size (dec (n/* +2 size))) (&.take size takes))))) - (and (List/= (list.n/range +0 (n/dec size)) + (and (List/= (list.n/range +0 (dec size)) (&.take-while (n/< size) sample0)) - (List/= (list.n/range offset (n/dec (n/+ offset size))) + (List/= (list.n/range offset (dec (n/+ offset size))) (&.take-while (n/< (n/+ offset size)) (&.drop-while (n/< offset) sample0))) (let [[drops takes] (&.split-while (n/< size) sample0)] - (and (List/= (list.n/range +0 (n/dec size)) + (and (List/= (list.n/range +0 (dec size)) drops) - (List/= (list.n/range size (n/dec (n/* +2 size))) + (List/= (list.n/range size (dec (n/* +2 size))) (&.take-while (n/< (n/* +2 size)) takes))))) )) @@ -52,17 +52,17 @@ (test "Can obtain the head & tail of a stream." (and (n/= offset (&.head sample1)) - (List/= (list.n/range (n/inc offset) (n/+ offset size)) + (List/= (list.n/range (inc offset) (n/+ offset size)) (&.take size (&.tail sample1))))) (test "Can filter streams." (and (n/= (n/* +2 offset) (&.nth offset (&.filter n/even? sample0))) - (let [[evens odds] (&.partition n/even? (&.iterate n/inc +0))] + (let [[evens odds] (&.partition n/even? (&.iterate inc +0))] (and (n/= (n/* +2 offset) (&.nth offset evens)) - (n/= (n/inc (n/* +2 offset)) + (n/= (inc (n/* +2 offset)) (&.nth offset odds)))))) (test "Functor goes over 'all' elements in a stream." @@ -86,9 +86,9 @@ (let [(^open "&/") &.Functor<Stream> (^open "List/") (list.Eq<List> text.Eq<Text>)] (List/= (&.take size - (&/map Nat/encode (&.iterate n/inc offset))) + (&/map Nat/encode (&.iterate inc offset))) (&.take size - (&.unfold (function (_ n) [(n/inc n) (Nat/encode n)]) + (&.unfold (function (_ n) [(inc n) (Nat/encode n)]) offset))))) (test "Can cycle over the same elements as an infinite stream." diff --git a/stdlib/test/test/lux/data/coll/tree/rose.lux b/stdlib/test/test/lux/data/coll/tree/rose.lux index 1bf29d533..fdc385515 100644 --- a/stdlib/test/test/lux/data/coll/tree/rose.lux +++ b/stdlib/test/test/lux/data/coll/tree/rose.lux @@ -22,7 +22,7 @@ children' (r.list num-children gen-tree) #let [size' (L/fold n/+ +0 (L/map product.left children')) children (L/map product.right children')]] - (wrap [(n/inc size') + (wrap [(inc size') (&.branch value children)])) )))) diff --git a/stdlib/test/test/lux/data/color.lux b/stdlib/test/test/lux/data/color.lux index b9290ed19..58bba6749 100644 --- a/stdlib/test/test/lux/data/color.lux +++ b/stdlib/test/test/lux/data/color.lux @@ -15,7 +15,7 @@ (def: scale (-> Nat Frac) - (|>> nat-to-int int-to-frac)) + (|>> .int int-to-frac)) (def: square (-> Frac Frac) (math.pow 2.0)) diff --git a/stdlib/test/test/lux/data/error.lux b/stdlib/test/test/lux/data/error.lux index fb66bc7fe..ed7b6cc58 100644 --- a/stdlib/test/test/lux/data/error.lux +++ b/stdlib/test/test/lux/data/error.lux @@ -13,20 +13,20 @@ ($_ seq (test "Functor correctly handles both cases." (and (|> (: (&.Error Int) (#&.Success 10)) - (&/map i/inc) + (&/map inc) (case> (#&.Success 11) true _ false)) (|> (: (&.Error Int) (#&.Error "YOLO")) - (&/map i/inc) + (&/map inc) (case> (#&.Error "YOLO") true _ false)) )) (test "Apply correctly handles both cases." (and (|> (&/wrap 20) (case> (#&.Success 20) true _ false)) - (|> (&/apply (&/wrap i/inc) (&/wrap 10)) + (|> (&/apply (&/wrap inc) (&/wrap 10)) (case> (#&.Success 11) true _ false)) - (|> (&/apply (&/wrap i/inc) (#&.Error "YOLO")) + (|> (&/apply (&/wrap inc) (#&.Error "YOLO")) (case> (#&.Error "YOLO") true _ false)))) (test "Monad correctly handles both cases." diff --git a/stdlib/test/test/lux/data/lazy.lux b/stdlib/test/test/lux/data/lazy.lux index 07513adec..da28003ba 100644 --- a/stdlib/test/test/lux/data/lazy.lux +++ b/stdlib/test/test/lux/data/lazy.lux @@ -31,22 +31,22 @@ ($_ seq (test "Functor map." (|> (&.freeze sample) - (:: &.Functor<Lazy> map n/inc) + (:: &.Functor<Lazy> map inc) &.thaw - (n/= (n/inc sample)))) + (n/= (inc sample)))) (test "Monad." (|> (do &.Monad<Lazy> - [f (wrap n/inc) + [f (wrap inc) a (wrap sample)] (wrap (f a))) &.thaw - (n/= (n/inc sample)))) + (n/= (inc sample)))) (test "Apply apply." (let [(^open "&/") &.Monad<Lazy> (^open "&/") &.Apply<Lazy>] - (|> (&/apply (&/wrap n/inc) (&/wrap sample)) + (|> (&/apply (&/wrap inc) (&/wrap sample)) &.thaw - (n/= (n/inc sample))))) + (n/= (inc sample))))) )))) diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux index 263dd346d..e6692fb3d 100644 --- a/stdlib/test/test/lux/data/number.lux +++ b/stdlib/test/test/lux/data/number.lux @@ -160,7 +160,7 @@ (do @ [raw r.frac factor (|> r.nat (:: @ map (|>> (n/% +1000) (n/max +1)))) - #let [sample (|> factor nat-to-int int-to-frac (f/* raw))]] + #let [sample (|> factor .int int-to-frac (f/* raw))]] (test "Can convert frac values to/from their bit patterns." (|> sample frac-to-bits bits-to-frac (f/= sample)))))) diff --git a/stdlib/test/test/lux/data/number/complex.lux b/stdlib/test/test/lux/data/number/complex.lux index 8369ad676..14ab1c76c 100644 --- a/stdlib/test/test/lux/data/number/complex.lux +++ b/stdlib/test/test/lux/data/number/complex.lux @@ -28,7 +28,7 @@ (do r.Monad<Random> [factor (|> r.nat (:: @ map (|>> (n/% +1000) (n/max +1)))) measure (|> r.frac (r.filter (f/> 0.0)))] - (wrap (f/* (|> factor nat-to-int int-to-frac) + (wrap (f/* (|> factor .int int-to-frac) measure)))) (def: gen-complex @@ -196,6 +196,6 @@ degree (|> r.nat (:: @ map (|>> (n/max +1) (n/% +5))))] (test "Can calculate the N roots for any complex number." (|> sample - (&.nth-roots degree) - (list/map (&.pow' (|> degree nat-to-int int-to-frac))) + (&.roots degree) + (list/map (&.pow' (|> degree .int int-to-frac))) (list.every? (within? margin-of-error sample))))))) diff --git a/stdlib/test/test/lux/io.lux b/stdlib/test/test/lux/io.lux index 43841a708..faddcf42d 100644 --- a/stdlib/test/test/lux/io.lux +++ b/stdlib/test/test/lux/io.lux @@ -10,7 +10,7 @@ (context: "I/O" ($_ seq (test "" (Text/= "YOLO" (&.run (&.io "YOLO")))) - (test "" (i/= 11 (&.run (:: &.Functor<IO> map i/inc (&.io 10))))) + (test "" (i/= 11 (&.run (:: &.Functor<IO> map inc (&.io 10))))) (test "" (i/= 10 (&.run (:: &.Monad<IO> wrap 10)))) (test "" (i/= 30 (&.run (let [(^open "&/") &.Apply<IO> (^open "&/") &.Monad<IO>] diff --git a/stdlib/test/test/lux/lang/syntax.lux b/stdlib/test/test/lux/lang/syntax.lux index 68830f271..01679b27a 100644 --- a/stdlib/test/test/lux/lang/syntax.lux +++ b/stdlib/test/test/lux/lang/syntax.lux @@ -110,8 +110,8 @@ (context: "Frac special syntax." (<| (times +100) (do @ - [numerator (|> r.nat (:: @ map (|>> (n/% +100) nat-to-frac))) - denominator (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1) nat-to-frac))) + [numerator (|> r.nat (:: @ map (|>> (n/% +100) .int int-to-frac))) + denominator (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1) .int int-to-frac))) signed? r.bool #let [expected (|> numerator (f// denominator) (f/* (if signed? -1.0 1.0)))]] (test "Can parse frac ratio syntax." @@ -201,7 +201,7 @@ (text.from-code y) "\n" (text.from-code z))] (case (&.read "" (dict.new text.Hash<Text>) - [(|> default-cursor (update@ #.column (n/+ (n/dec offset-size)))) + [(|> default-cursor (update@ #.column (n/+ (dec offset-size)))) +0 (format "\"" good-input "\"")]) (#e.Error error) diff --git a/stdlib/test/test/lux/lang/type/check.lux b/stdlib/test/test/lux/lang/type/check.lux index e10ac5514..517b2561b 100644 --- a/stdlib/test/test/lux/lang/type/check.lux +++ b/stdlib/test/test/lux/lang/type/check.lux @@ -216,7 +216,7 @@ tailR (@.ring tail-id)] (@.assert "" (let [same-rings? (:: set.Eq<Set> = headR tailR) - expected-size? (n/= (n/inc num-connections) (set.size headR)) + expected-size? (n/= (inc num-connections) (set.size headR)) same-vars? (|> (set.to-list headR) (list.sort n/<) (:: (list.Eq<List> number.Eq<Nat>) = (list.sort n/< (#.Cons head-id ids))))] @@ -252,7 +252,7 @@ headRR-post (@.ring head-idR)] (@.assert "" (let [same-rings? (:: set.Eq<Set> = headRL-post headRR-post) - expected-size? (n/= (n/* +2 (n/inc num-connections)) + expected-size? (n/= (n/* +2 (inc num-connections)) (set.size headRL-post)) union? (:: set.Eq<Set> = headRL-post (set.union headRL-pre headRR-pre))] (and same-rings? diff --git a/stdlib/test/test/lux/type/implicit.lux b/stdlib/test/test/lux/type/implicit.lux index 2ae01ed1b..c07067b3e 100644 --- a/stdlib/test/test/lux/type/implicit.lux +++ b/stdlib/test/test/lux/type/implicit.lux @@ -22,7 +22,7 @@ (and (bool/= (:: number.Eq<Nat> = x y) (::: = x y)) (list/= (list.n/range +1 +10) - (::: map n/inc (list.n/range +0 +9))) + (::: map inc (list.n/range +0 +9))) ))) (test "Can automatically select second-order structures." diff --git a/stdlib/test/test/lux/type/object/interface.lux b/stdlib/test/test/lux/type/object/interface.lux index 7def3113a..f74d32e2a 100644 --- a/stdlib/test/test/lux/type/object/interface.lux +++ b/stdlib/test/test/lux/type/object/interface.lux @@ -5,16 +5,16 @@ ## No parameters (interface: Counter - (inc [] @) - (read [] Nat)) + (inc! [] @) + (read! [] Nat)) (class: NatC Counter Nat - (def: inc - (update@Counter n/inc)) + (def: inc! + (update@Counter inc)) - (def: read + (def: read! get@Counter)) (interface: Resettable-Counter @@ -56,28 +56,28 @@ ## Polymorphism (def: (poly0 counter) (-> Counter Nat) - (read counter)) + (read! counter)) (def: poly0-0 Nat (poly0 (new@NatC +0))) (def: poly0-1 Nat (poly0 (new@NatRC +0 []))) (def: (poly1 counter) (-> Resettable-Counter Nat) - (n/+ (read counter) - (read (reset counter)))) + (n/+ (read! counter) + (read! (reset counter)))) (def: poly1-0 Nat (poly1 (new@NatRC +0 []))) (def: (poly2 counter) (-> NatC Nat) - (read counter)) + (read! counter)) (def: poly2-0 Nat (poly2 (new@NatC +0))) (def: poly2-1 Nat (poly2 (new@NatRC +0 []))) (def: (poly3 counter) (-> NatRC Nat) - (n/+ (read counter) - (read (reset counter)))) + (n/+ (read! counter) + (read! (reset counter)))) (def: poly3-0 Nat (poly3 (new@NatRC +0 []))) diff --git a/stdlib/test/test/lux/type/object/protocol.lux b/stdlib/test/test/lux/type/object/protocol.lux index e5a8dda4b..fcb53d3b1 100644 --- a/stdlib/test/test/lux/type/object/protocol.lux +++ b/stdlib/test/test/lux/type/object/protocol.lux @@ -7,7 +7,7 @@ (def: (count [tick return] state) (Class Nat (Method Top Nat)) - (let [state' (n/inc state)] + (let [state' (inc state)] [(return state') state'])) (def: counter @@ -38,7 +38,7 @@ (#method2 [arg0 arg1 arg2] output) (output (%n num-calls))) - (recur (n/inc num-calls))]))) + (recur (inc num-calls))]))) (def: _test1 [Nat Object0] diff --git a/stdlib/test/test/lux/world/blob.lux b/stdlib/test/test/lux/world/blob.lux index 37deb9d3b..1093f302f 100644 --- a/stdlib/test/test/lux/world/blob.lux +++ b/stdlib/test/test/lux/world/blob.lux @@ -29,14 +29,14 @@ (do r.Monad<Random> [byte r.nat] (exec (e.assume (/.write-8 idx byte output)) - (recur (n/inc idx)))) + (recur (inc idx)))) (:: r.Monad<Random> wrap output))))) (def: (bits-io bytes read write value) (-> Nat (-> Nat /.Blob (e.Error Nat)) (-> Nat Nat /.Blob (e.Error Top)) Nat Bool) (let [blob (/.create +8) bits (n/* +8 bytes) - capped-value (|> +1 (bit.left-shift bits) n/dec (bit.and value))] + capped-value (|> +1 (bit.left-shift bits) dec (bit.and value))] (succeed (do e.Monad<Error> [_ (write +0 value blob) @@ -67,9 +67,9 @@ (test "Can read/write 64-bit values." (bits-io +8 /.read-64 /.write-64 value)) (test "Can slice blobs." - (let [slice-size (|> to (n/- from) n/inc) + (let [slice-size (|> to (n/- from) inc) random-slice (e.assume (/.slice from to random-blob)) - idxs (list.n/range +0 (n/dec slice-size)) + idxs (list.n/range +0 (dec slice-size)) reader (function (_ blob idx) (/.read-8 idx blob))] (and (n/= slice-size (/.size random-slice)) (case [(monad.map e.Monad<Error> (reader random-slice) idxs) diff --git a/stdlib/test/test/lux/world/file.lux b/stdlib/test/test/lux/world/file.lux index 6f4e26e6d..6d32a994b 100644 --- a/stdlib/test/test/lux/world/file.lux +++ b/stdlib/test/test/lux/world/file.lux @@ -73,8 +73,8 @@ read-size (@.size file) _ (@.delete file)] (wrap (and (n/= (n/* +2 file-size) read-size) - (:: blob.Eq<Blob> = dataL (e.assume (blob.slice +0 (n/dec file-size) output))) - (:: blob.Eq<Blob> = dataR (e.assume (blob.slice file-size (n/dec read-size) output)))))))] + (:: blob.Eq<Blob> = dataL (e.assume (blob.slice +0 (dec file-size) output))) + (:: blob.Eq<Blob> = dataR (e.assume (blob.slice file-size (dec read-size) output)))))))] (assert "Can append to files." (e.default false result)))) (wrap (do P.Monad<Promise> |