diff options
Diffstat (limited to 'stdlib')
168 files changed, 2489 insertions, 2475 deletions
diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux index a9c442462..34ceb43ba 100644 --- a/stdlib/source/lux.lux +++ b/stdlib/source/lux.lux @@ -1,194 +1,194 @@ ("lux def" dummy-cursor - ("lux check" (+2 (+0 "#Text" (+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?"])] - [["" +0 +0] (+0 #1)]] - (+0)))]) + ("lux check" (2 (0 "#Text" (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?"])] + [["" 0 0] (0 #1)]] + (0)))]) ## (type: Any ## (Ex [a] a)) ("lux def" Any - (+10 ["lux" "Any"] - (+8 (+0) (+4 +1))) + (10 ["lux" "Any"] + (8 (0) (4 1))) [dummy-cursor - (+10 (+1 [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (+1 [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (+1 [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "The type of things whose type does not matter. + (10 (1 [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (1 [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (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.")]] - (+0)))))]) + (0)))))]) ## (type: Nothing ## (All [a] a)) ("lux def" Nothing - (+10 ["lux" "Nothing"] - (+7 (+0) (+4 +1))) + (10 ["lux" "Nothing"] + (7 (0) (4 1))) [dummy-cursor - (+10 (+1 [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (+1 [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (+1 [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "The type of things whose type is unknown or undefined. + (10 (1 [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (1 [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (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.")]] - (+0)))))]) + (0)))))]) ## (type: (List a) ## #Nil ## (#Cons a (List a))) ("lux def" List - (+10 ["lux" "List"] - (+7 (+0) - (+1 ## "lux.Nil" - Any - ## "lux.Cons" - (+2 (+4 +1) - (+9 (+4 +1) (+4 +0)))))) + (10 ["lux" "List"] + (7 (0) + (1 ## "lux.Nil" + Any + ## "lux.Cons" + (2 (4 1) + (9 (4 1) (4 0)))))) [dummy-cursor - (+10 (+1 [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (+1 [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (+1 [[dummy-cursor (+7 ["lux" "tags"])] - [dummy-cursor (+9 (+1 [dummy-cursor (+5 "Nil")] (+1 [dummy-cursor (+5 "Cons")] (+0))))]] - (+1 [[dummy-cursor (+7 ["lux" "type-args"])] - [dummy-cursor (+9 (+1 [dummy-cursor (+5 "a")] (+0)))]] - (+1 [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "A potentially empty list of values.")]] - (+0)))))))]) + (10 (1 [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (1 [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (1 [[dummy-cursor (7 ["lux" "tags"])] + [dummy-cursor (9 (1 [dummy-cursor (5 "Nil")] (1 [dummy-cursor (5 "Cons")] (0))))]] + (1 [[dummy-cursor (7 ["lux" "type-args"])] + [dummy-cursor (9 (1 [dummy-cursor (5 "a")] (0)))]] + (1 [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "A potentially empty list of values.")]] + (0)))))))]) ("lux def" Bit - (+10 ["lux" "Bit"] - (+0 "#Bit" #Nil)) + (10 ["lux" "Bit"] + (0 "#Bit" #Nil)) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "Your standard, run-of-the-mill boolean values (as bits).")]] - #Nil))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "Your standard, run-of-the-mill boolean values (as bits).")]] + #Nil))))]) ("lux def" I64 - (+10 ["lux" "I64"] - (+7 (+0) - (+0 "#I64" (#Cons (+4 +1) #Nil)))) + (10 ["lux" "I64"] + (7 (0) + (0 "#I64" (#Cons (4 1) #Nil)))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "64-bit integers without any semantics.")]] - #Nil))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "64-bit integers without any semantics.")]] + #Nil))))]) ("lux def" Nat - (+10 ["lux" "Nat"] - (+0 "#I64" (#Cons (+0 "#Nat" #Nil) #Nil))) + (10 ["lux" "Nat"] + (0 "#I64" (#Cons (0 "#Nat" #Nil) #Nil))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "Natural numbers (unsigned integers). + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "Natural numbers (unsigned integers). - They start at zero (+0) and extend in the positive direction.")]] - #Nil))))]) + They start at zero (0) and extend in the positive direction.")]] + #Nil))))]) ("lux def" Int - (+10 ["lux" "Int"] - (+0 "#I64" (#Cons (+0 "#Int" #Nil) #Nil))) + (10 ["lux" "Int"] + (0 "#I64" (#Cons (0 "#Int" #Nil) #Nil))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "Your standard, run-of-the-mill integer numbers.")]] - #Nil))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "Your standard, run-of-the-mill integer numbers.")]] + #Nil))))]) ("lux def" Rev - (+10 ["lux" "Rev"] - (+0 "#I64" (#Cons (+0 "#Rev" #Nil) #Nil))) + (10 ["lux" "Rev"] + (0 "#I64" (#Cons (0 "#Rev" #Nil) #Nil))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "Fractional numbers that live in the interval [0,1). + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#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.")]] - #Nil))))]) + #Nil))))]) ("lux def" Frac - (+10 ["lux" "Frac"] - (+0 "#Frac" #Nil)) + (10 ["lux" "Frac"] + (0 "#Frac" #Nil)) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "Your standard, run-of-the-mill floating-point (fractional) numbers.")]] - #Nil))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "Your standard, run-of-the-mill floating-point (fractional) numbers.")]] + #Nil))))]) ("lux def" Text - (+10 ["lux" "Text"] - (+0 "#Text" #Nil)) + (10 ["lux" "Text"] + (0 "#Text" #Nil)) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "Your standard, run-of-the-mill string values.")]] - #Nil))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "Your standard, run-of-the-mill string values.")]] + #Nil))))]) ("lux def" Name - (+10 ["lux" "Name"] - (+2 Text Text)) + (10 ["lux" "Name"] + (2 Text Text)) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "A name. + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "A name. It is used as part of Lux syntax to represent identifiers and tags.")]] - #Nil))))]) + #Nil))))]) ## (type: (Maybe a) ## #None ## (#Some a)) ("lux def" Maybe - (+10 ["lux" "Maybe"] - (+7 #Nil - (+1 ## "lux.None" - Any - ## "lux.Some" - (+4 +1)))) + (10 ["lux" "Maybe"] + (7 #Nil + (1 ## "lux.None" + Any + ## "lux.Some" + (4 1)))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "tags"])] - [dummy-cursor (+9 (#Cons [dummy-cursor (+5 "None")] (#Cons [dummy-cursor (+5 "Some")] #Nil)))]] - (#Cons [[dummy-cursor (+7 ["lux" "type-args"])] - [dummy-cursor (+9 (#Cons [dummy-cursor (+5 "a")] #Nil))]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "A potentially missing value.")]] - #Nil))))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "tags"])] + [dummy-cursor (9 (#Cons [dummy-cursor (5 "None")] (#Cons [dummy-cursor (5 "Some")] #Nil)))]] + (#Cons [[dummy-cursor (7 ["lux" "type-args"])] + [dummy-cursor (9 (#Cons [dummy-cursor (5 "a")] #Nil))]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "A potentially missing value.")]] + #Nil))))))]) ## (type: #rec Type ## (#Primitive Text (List Type)) @@ -204,60 +204,60 @@ ## (#Named Name Type) ## ) ("lux def" Type - (+10 ["lux" "Type"] - ({Type - ({Type-List - ({Type-Pair - (+9 Nothing - (+7 #Nil - (+1 ## "lux.Primitive" - (+2 Text Type-List) - (+1 ## "lux.Sum" - Type-Pair - (+1 ## "lux.Product" - Type-Pair - (+1 ## "lux.Function" - Type-Pair - (+1 ## "lux.Parameter" - Nat - (+1 ## "lux.Var" - Nat - (+1 ## "lux.Ex" - Nat - (+1 ## "lux.UnivQ" - (+2 Type-List Type) - (+1 ## "lux.ExQ" - (+2 Type-List Type) - (+1 ## "lux.Apply" - Type-Pair - ## "lux.Named" - (+2 Name Type)))))))))))))} - ("lux check type" (+2 Type Type)))} - ("lux check type" (+9 Type List)))} - ("lux check type" (+9 (+4 +1) (+4 +0))))) + (10 ["lux" "Type"] + ({Type + ({Type-List + ({Type-Pair + (9 Nothing + (7 #Nil + (1 ## "lux.Primitive" + (2 Text Type-List) + (1 ## "lux.Sum" + Type-Pair + (1 ## "lux.Product" + Type-Pair + (1 ## "lux.Function" + Type-Pair + (1 ## "lux.Parameter" + Nat + (1 ## "lux.Var" + Nat + (1 ## "lux.Ex" + Nat + (1 ## "lux.UnivQ" + (2 Type-List Type) + (1 ## "lux.ExQ" + (2 Type-List Type) + (1 ## "lux.Apply" + Type-Pair + ## "lux.Named" + (2 Name Type)))))))))))))} + ("lux check type" (2 Type Type)))} + ("lux check type" (9 Type List)))} + ("lux check type" (9 (4 1) (4 0))))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "tags"])] - [dummy-cursor (+9 (#Cons [dummy-cursor (+5 "Primitive")] - (#Cons [dummy-cursor (+5 "Sum")] - (#Cons [dummy-cursor (+5 "Product")] - (#Cons [dummy-cursor (+5 "Function")] - (#Cons [dummy-cursor (+5 "Parameter")] - (#Cons [dummy-cursor (+5 "Var")] - (#Cons [dummy-cursor (+5 "Ex")] - (#Cons [dummy-cursor (+5 "UnivQ")] - (#Cons [dummy-cursor (+5 "ExQ")] - (#Cons [dummy-cursor (+5 "Apply")] - (#Cons [dummy-cursor (+5 "Named")] - #Nil))))))))))))]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "This type represents the data-structures that are used to specify types themselves.")]] - (#Cons [[dummy-cursor (+7 ["lux" "type-rec?"])] - [dummy-cursor (+0 #1)]] - #Nil))))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "tags"])] + [dummy-cursor (9 (#Cons [dummy-cursor (5 "Primitive")] + (#Cons [dummy-cursor (5 "Sum")] + (#Cons [dummy-cursor (5 "Product")] + (#Cons [dummy-cursor (5 "Function")] + (#Cons [dummy-cursor (5 "Parameter")] + (#Cons [dummy-cursor (5 "Var")] + (#Cons [dummy-cursor (5 "Ex")] + (#Cons [dummy-cursor (5 "UnivQ")] + (#Cons [dummy-cursor (5 "ExQ")] + (#Cons [dummy-cursor (5 "Apply")] + (#Cons [dummy-cursor (5 "Named")] + #Nil))))))))))))]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "This type represents the data-structures that are used to specify types themselves.")]] + (#Cons [[dummy-cursor (7 ["lux" "type-rec?"])] + [dummy-cursor (0 #1)]] + #Nil))))))]) ## (type: Cursor ## {#module Text @@ -267,18 +267,18 @@ (#Named ["lux" "Cursor"] (#Product Text (#Product Nat Nat))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "tags"])] - [dummy-cursor (+9 (#Cons [dummy-cursor (+5 "module")] - (#Cons [dummy-cursor (+5 "line")] - (#Cons [dummy-cursor (+5 "column")] - #Nil))))]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "Cursors are for specifying the location of Code nodes in Lux files during compilation.")]] - (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - #Nil)))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "tags"])] + [dummy-cursor (9 (#Cons [dummy-cursor (5 "module")] + (#Cons [dummy-cursor (5 "line")] + (#Cons [dummy-cursor (5 "column")] + #Nil))))]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "Cursors are for specifying the location of Code nodes in Lux files during compilation.")]] + (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + #Nil)))))]) ## (type: (Ann m v) ## {#meta m @@ -287,22 +287,22 @@ (#Named ["lux" "Ann"] (#UnivQ #Nil (#UnivQ #Nil - (#Product (#Parameter +3) - (#Parameter +1))))) + (#Product (#Parameter 3) + (#Parameter 1))))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "tags"])] - [dummy-cursor (+9 (#Cons [dummy-cursor (+5 "meta")] - (#Cons [dummy-cursor (+5 "datum")] - #Nil)))]] - (#Cons [[dummy-cursor (+7 ["lux" "doc"])] - [dummy-cursor (+5 "The type of things that can be annotated with meta-data of arbitrary types.")]] - (#Cons [[dummy-cursor (+7 ["lux" "type-args"])] - [dummy-cursor (+9 (#Cons [dummy-cursor (+5 "m")] (#Cons [dummy-cursor (+5 "v")] #Nil)))]] - (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - #Nil))))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "tags"])] + [dummy-cursor (9 (#Cons [dummy-cursor (5 "meta")] + (#Cons [dummy-cursor (5 "datum")] + #Nil)))]] + (#Cons [[dummy-cursor (7 ["lux" "doc"])] + [dummy-cursor (5 "The type of things that can be annotated with meta-data of arbitrary types.")]] + (#Cons [[dummy-cursor (7 ["lux" "type-args"])] + [dummy-cursor (9 (#Cons [dummy-cursor (5 "m")] (#Cons [dummy-cursor (5 "v")] #Nil)))]] + (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + #Nil))))))]) ## (type: (Code' w) ## (#Bit Bit) @@ -346,30 +346,30 @@ )))))))))) )} ("lux check type" (#Apply Code List)))} - ("lux check type" (#Apply (#Apply (#Parameter +1) - (#Parameter +0)) - (#Parameter +1))))) + ("lux check type" (#Apply (#Apply (#Parameter 1) + (#Parameter 0)) + (#Parameter 1))))) [dummy-cursor - (+10 (#Cons [[dummy-cursor (+7 ["lux" "tags"])] - [dummy-cursor (+9 (#Cons [dummy-cursor (+5 "Bit")] - (#Cons [dummy-cursor (+5 "Nat")] - (#Cons [dummy-cursor (+5 "Int")] - (#Cons [dummy-cursor (+5 "Rev")] - (#Cons [dummy-cursor (+5 "Frac")] - (#Cons [dummy-cursor (+5 "Text")] - (#Cons [dummy-cursor (+5 "Identifier")] - (#Cons [dummy-cursor (+5 "Tag")] - (#Cons [dummy-cursor (+5 "Form")] - (#Cons [dummy-cursor (+5 "Tuple")] - (#Cons [dummy-cursor (+5 "Record")] - #Nil))))))))))))]] - (#Cons [[dummy-cursor (+7 ["lux" "type-args"])] - [dummy-cursor (+9 (#Cons [dummy-cursor (+5 "w")] #Nil))]] - (#Cons [[dummy-cursor (+7 ["lux" "type?"])] - [dummy-cursor (+0 #1)]] - (#Cons [[dummy-cursor (+7 ["lux" "export?"])] - [dummy-cursor (+0 #1)]] - #Nil)))))]) + (10 (#Cons [[dummy-cursor (7 ["lux" "tags"])] + [dummy-cursor (9 (#Cons [dummy-cursor (5 "Bit")] + (#Cons [dummy-cursor (5 "Nat")] + (#Cons [dummy-cursor (5 "Int")] + (#Cons [dummy-cursor (5 "Rev")] + (#Cons [dummy-cursor (5 "Frac")] + (#Cons [dummy-cursor (5 "Text")] + (#Cons [dummy-cursor (5 "Identifier")] + (#Cons [dummy-cursor (5 "Tag")] + (#Cons [dummy-cursor (5 "Form")] + (#Cons [dummy-cursor (5 "Tuple")] + (#Cons [dummy-cursor (5 "Record")] + #Nil))))))))))))]] + (#Cons [[dummy-cursor (7 ["lux" "type-args"])] + [dummy-cursor (9 (#Cons [dummy-cursor (5 "w")] #Nil))]] + (#Cons [[dummy-cursor (7 ["lux" "type?"])] + [dummy-cursor (0 #1)]] + (#Cons [[dummy-cursor (7 ["lux" "export?"])] + [dummy-cursor (0 #1)]] + #Nil)))))]) ## (type: Code ## (Ann Cursor (Code' (Ann Cursor)))) @@ -490,8 +490,8 @@ (#Product ## "lux.counter" Nat ## "lux.mappings" - (#Apply (#Product (#Parameter +3) - (#Parameter +1)) + (#Apply (#Product (#Parameter 3) + (#Parameter 1)) List))))) (record$ (#Cons [(tag$ ["lux" "tags"]) (tuple$ (#Cons (text$ "counter") (#Cons (text$ "mappings") #Nil)))] @@ -543,9 +543,9 @@ (#UnivQ #Nil (#UnivQ #Nil (#Sum ## "lux.Left" - (#Parameter +3) + (#Parameter 3) ## "lux.Right" - (#Parameter +1))))) + (#Parameter 1))))) (record$ (#Cons [(tag$ ["lux" "tags"]) (tuple$ (#Cons (text$ "Left") (#Cons (text$ "Right") #Nil)))] (#Cons [(tag$ ["lux" "type-args"]) @@ -760,7 +760,7 @@ (#Named ["lux" "Meta"] (#UnivQ #Nil (#Function Lux - (#Apply (#Product Lux (#Parameter +1)) + (#Apply (#Product Lux (#Parameter 1)) (#Apply Text Either))))) (record$ (#Cons [(tag$ ["lux" "doc"]) (text$ "Computations that can have access to the state of the compiler. @@ -782,10 +782,10 @@ ## Base functions & macros ("lux def" return ("lux check" (#UnivQ #Nil - (#Function (#Parameter +1) + (#Function (#Parameter 1) (#Function Lux (#Apply (#Product Lux - (#Parameter +1)) + (#Parameter 1)) (#Apply Text Either))))) ([_ val] ([_ state] @@ -797,7 +797,7 @@ (#Function Text (#Function Lux (#Apply (#Product Lux - (#Parameter +1)) + (#Parameter 1)) (#Apply Text Either))))) ([_ msg] ([_ state] @@ -861,7 +861,7 @@ ("lux def" cursor-code ("lux check" Code - (tuple$ (#Cons (text$ "") (#Cons (nat$ +0) (#Cons (nat$ +0) #Nil))))) + (tuple$ (#Cons (text$ "") (#Cons (nat$ 0) (#Cons (nat$ 0) #Nil))))) (record$ #Nil)) ("lux def" meta-code @@ -1029,7 +1029,7 @@ (#Cons [(tag$ ["lux" "doc"]) (text$ "## Throws away any code given to it. ## Great for commenting-out code, while retaining syntax high-lighting and formatting in your text editor. - (comment 1 2 3 4)")] + (comment +1 +2 +3 +4)")] #Nil) (return #Nil)) @@ -1052,9 +1052,9 @@ #Nil (#UnivQ #Nil (#UnivQ #Nil - (#Function (#Function (#Parameter +3) (#Parameter +1)) - (#Function ($' List (#Parameter +3)) - ($' List (#Parameter +1)))))) + (#Function (#Function (#Parameter 3) (#Parameter 1)) + (#Function ($' List (#Parameter 3)) + ($' List (#Parameter 1)))))) ({#Nil #Nil @@ -1164,7 +1164,7 @@ pairs)) [_ (#Form (#Cons [_ (#Tag "lux" "Parameter")] (#Cons [_ (#Nat idx)] #Nil)))] - (form$ (#Cons (tag$ ["lux" "Parameter"]) (#Cons (nat$ (n/+ +2 idx)) #Nil))) + (form$ (#Cons (tag$ ["lux" "Parameter"]) (#Cons (nat$ (n/+ 2 idx)) #Nil))) [_ (#Form members)] (form$ (list/map update-parameters members)) @@ -1198,12 +1198,12 @@ (def:'' (list/fold f init xs) #Nil ## (All [a b] (-> (-> b a a) a (List b) a)) - (#UnivQ #Nil (#UnivQ #Nil (#Function (#Function (#Parameter +1) - (#Function (#Parameter +3) - (#Parameter +3))) - (#Function (#Parameter +3) - (#Function ($' List (#Parameter +1)) - (#Parameter +3)))))) + (#UnivQ #Nil (#UnivQ #Nil (#Function (#Function (#Parameter 1) + (#Function (#Parameter 3) + (#Parameter 3))) + (#Function (#Parameter 3) + (#Function ($' List (#Parameter 1)) + (#Parameter 3)))))) ({#Nil init @@ -1214,8 +1214,8 @@ (def:'' (list/size list) #Nil (#UnivQ #Nil - (#Function ($' List (#Parameter +1)) Nat)) - (list/fold (function'' [_ acc] (n/+ +1 acc)) +0 list)) + (#Function ($' List (#Parameter 1)) Nat)) + (list/fold (function'' [_ acc] (n/+ 1 acc)) 0 list)) (macro:' #export (All tokens) (#Cons [(tag$ ["lux" "doc"]) @@ -1241,7 +1241,7 @@ (function'' [name' body'] (form$ (#Cons (tag$ ["lux" "UnivQ"]) (#Cons (tag$ ["lux" "Nil"]) - (#Cons (replace-syntax (#Cons [name' (make-parameter +1)] #Nil) + (#Cons (replace-syntax (#Cons [name' (make-parameter 1)] #Nil) (update-parameters body')) #Nil)))))) body names) @@ -1252,7 +1252,7 @@ body' [#0 _] - (replace-syntax (#Cons [self-name (make-parameter (n/* +2 (n/- +1 (list/size names))))] + (replace-syntax (#Cons [self-name (make-parameter (n/* 2 (n/- 1 (list/size names))))] #Nil) body')} [(text/= "" self-name) names]) @@ -1288,7 +1288,7 @@ (function'' [name' body'] (form$ (#Cons (tag$ ["lux" "ExQ"]) (#Cons (tag$ ["lux" "Nil"]) - (#Cons (replace-syntax (#Cons [name' (make-parameter +1)] #Nil) + (#Cons (replace-syntax (#Cons [name' (make-parameter 1)] #Nil) (update-parameters body')) #Nil)))))) body names) @@ -1299,7 +1299,7 @@ body' [#0 _] - (replace-syntax (#Cons [self-name (make-parameter (n/* +2 (n/- +1 (list/size names))))] + (replace-syntax (#Cons [self-name (make-parameter (n/* 2 (n/- 1 (list/size names))))] #Nil) body')} [(text/= "" self-name) names]) @@ -1338,7 +1338,7 @@ (macro:' #export (list xs) (#Cons [(tag$ ["lux" "doc"]) (text$ "## List-construction macro. - (list 1 2 3)")] + (list +1 +2 +3)")] #Nil) (return (#Cons (list/fold (function'' [head tail] (form$ (#Cons (tag$ ["lux" "Cons"]) @@ -1352,7 +1352,7 @@ (#Cons [(tag$ ["lux" "doc"]) (text$ "## List-construction macro, with the last element being a tail-list. ## In other words, this macro prepends elements to another list. - (list& 1 2 3 (list 4 5 6))")] + (list& +1 +2 +3 (list +4 +5 +6))")] #Nil) ({(#Cons last init) (return (list (list/fold (function'' [head tail] @@ -1518,7 +1518,7 @@ (def:''' (wrap-meta content) #Nil (-> Code Code) - (tuple$ (list (tuple$ (list (text$ "") (nat$ +0) (nat$ +0))) + (tuple$ (list (tuple$ (list (text$ "") (nat$ 0) (nat$ 0))) content))) (def:''' (untemplate-list tokens) @@ -2199,14 +2199,14 @@ (def:''' (high-bits value) (list) (-> ($' I64 Any) I64) - ("lux i64 logical-right-shift" +32 value)) + ("lux i64 logical-right-shift" 32 value)) (def:''' low-mask (list) I64 - (|> +1 - ("lux i64 left-shift" +32) - ("lux i64 -" +1))) + (|> 1 + ("lux i64 left-shift" 32) + ("lux i64 -" 1))) (def:''' (low-bits value) (list) @@ -2257,7 +2257,7 @@ (-> Int Int) (i/+ <diff>))] - [inc 1] + [inc +1] [dec -1])")]) ({(#Cons [[_ (#Tuple bindings)] (#Cons [[_ (#Tuple templates)] data])]) ({[(#Some bindings') (#Some data')] @@ -2364,14 +2364,14 @@ (list [(tag$ ["lux" "doc"]) (text$ "Nat(ural) division.")]) (-> Nat Nat Nat) - (if ("lux int <" ("lux coerce" Int param) 0) + (if ("lux int <" ("lux coerce" Int param) +0) (if (n/< param subject) - +0 - +1) + 0 + 1) (let' [quotient ("lux i64 left-shift" - +1 + 1 ("lux int /" - ("lux i64 logical-right-shift" +1 subject) + ("lux i64 logical-right-shift" 1 subject) ("lux coerce" Int param))) flat ("lux int *" ("lux coerce" Int quotient) @@ -2379,7 +2379,7 @@ remainder ("lux i64 -" flat subject)] (if (n/< param remainder) quotient - ("lux i64 +" +1 quotient))))) + ("lux i64 +" 1 quotient))))) (def:''' #export (n//% param subject) (list [(tag$ ["lux" "doc"]) @@ -2442,7 +2442,7 @@ paramL (low-bits param) bottom (|> subjectL ("lux int *" paramL) - ("lux i64 logical-right-shift" +32)) + ("lux i64 logical-right-shift" 32)) middle ("lux i64 +" ("lux int *" subjectH paramL) ("lux int *" subjectL paramH)) @@ -2452,32 +2452,32 @@ high-bits ("lux i64 +" top)))) -(def:''' least-significant-bit-mask (list) Nat +1) +(def:''' least-significant-bit-mask (list) Nat 1) (def:''' (without-trailing-zeroes count remaining) (list) (-> Nat Nat (#Product Nat Nat)) (if (|> remaining ("lux i64 and" least-significant-bit-mask) - ("lux i64 =" +0)) + ("lux i64 =" 0)) (without-trailing-zeroes - ("lux i64 +" +1 count) - ("lux i64 logical-right-shift" +1 remaining)) + ("lux i64 +" 1 count) + ("lux i64 logical-right-shift" 1 remaining)) [count remaining])) (def:''' #export (r// param subject) (list [(tag$ ["lux" "doc"]) (text$ "Rev(olution) division.")]) (-> Rev Rev Rev) - (if ("lux i64 =" 0 param) + (if ("lux i64 =" +0 param) ("lux io error" "Cannot divide Rev by zero!") - (let' [[trailing-zeroes remaining] (without-trailing-zeroes +0 ("lux coerce" Nat param)) + (let' [[trailing-zeroes remaining] (without-trailing-zeroes 0 ("lux coerce" Nat param)) [trailing-zeroes denominator] ("lux check" (#Product Nat Nat) - (if ("lux i64 =" 0 trailing-zeroes) - [+1 ("lux i64 logical-right-shift" +1 remaining)] + (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)] + shift ("lux i64 -" trailing-zeroes 64) + numerator ("lux i64 left-shift" shift 1)] ("lux coerce" Rev ("lux int *" ("lux coerce" Int subject) @@ -2507,10 +2507,10 @@ (text$ "Rev(olution) reciprocal of a Nat(ural).")]) (-> Nat Rev) ("lux coerce" Rev - (let' [[trailing-zeroes remaining] (without-trailing-zeroes +0 numerator)] + (let' [[trailing-zeroes remaining] (without-trailing-zeroes 0 numerator)] (n// remaining - ({+0 ("lux coerce" Nat -1) - _ ("lux i64 left-shift" (n/- trailing-zeroes +64) +1)} + ({0 ("lux coerce" Nat -1) + _ ("lux i64 left-shift" (n/- trailing-zeroes 64) 1)} trailing-zeroes))))) (do-template [<name> <type> <test> <doc>] @@ -2543,26 +2543,26 @@ (def:''' (digit-to-text digit) #Nil (-> Nat Text) - ({+0 "0" - +1 "1" +2 "2" +3 "3" - +4 "4" +5 "5" +6 "6" - +7 "7" +8 "8" +9 "9" + ({0 "0" + 1 "1" 2 "2" 3 "3" + 4 "4" 5 "5" 6 "6" + 7 "7" 8 "8" 9 "9" _ ("lux io error" "undefined")} digit)) (def:''' (nat/encode value) #Nil (-> Nat Text) - ({+0 - "+0" + ({0 + "0" _ (let' [loop ("lux check" (-> Nat Text Text) (function' recur [input output] - (if (n/= +0 input) - (text/compose "+" output) - (recur (n// +10 input) - (text/compose (|> input (n/% +10) digit-to-text) + (if (n/= 0 input) + output + (recur (n// 10 input) + (text/compose (|> input (n/% 10) digit-to-text) output)))))] (loop value ""))} value)) @@ -2570,27 +2570,27 @@ (def:''' (int/abs value) #Nil (-> Int Int) - (if (i/< 0 value) + (if (i/< +0 value) (i/* -1 value) value)) (def:''' (int/encode value) #Nil (-> Int Text) - (if (i/= 0 value) + (if (i/= +0 value) "0" - (let' [sign (if (i/> 0 value) + (let' [sign (if (i/> +0 value) "" "-")] (("lux check" (-> Int Text Text) (function' recur [input output] - (if (i/= 0 input) + (if (i/= +0 input) (text/compose sign output) - (recur (i// 10 input) - (text/compose (|> input (i/% 10) ("lux coerce" Nat) digit-to-text) + (recur (i// +10 input) + (text/compose (|> input (i/% +10) ("lux coerce" Nat) digit-to-text) output))))) - (|> value (i// 10) int/abs) - (|> value (i/% 10) int/abs ("lux coerce" Nat) digit-to-text))))) + (|> value (i// +10) int/abs) + (|> value (i/% +10) int/abs ("lux coerce" Nat) digit-to-text))))) (def:''' (frac/encode x) #Nil @@ -2600,7 +2600,7 @@ (def:''' (multiple? div n) #Nil (-> Nat Nat Bit) - (|> n (n/% div) (n/= +0))) + (|> n (n/% div) (n/= 0))) (def:''' #export (not x) (list [(tag$ ["lux" "doc"]) @@ -2836,7 +2836,7 @@ (macro:' #export (: tokens) (list [(tag$ ["lux" "doc"]) (text$ "## The type-annotation macro. - (: (List Int) (list 1 2 3))")]) + (: (List Int) (list +1 +2 +3))")]) ({(#Cons type (#Cons value #Nil)) (return (list (` ("lux check" (type (~ type)) (~ value))))) @@ -2847,7 +2847,7 @@ (macro:' #export (:coerce tokens) (list [(tag$ ["lux" "doc"]) (text$ "## The type-coercion macro. - (:coerce Dinosaur (list 1 2 3))")]) + (:coerce Dinosaur (list +1 +2 +3))")]) ({(#Cons type (#Cons value #Nil)) (return (list (` ("lux coerce" (type (~ type)) (~ value))))) @@ -2935,7 +2935,7 @@ #scope-type-vars scope-type-vars} (#Right {#info info #source source #current-module _ #modules modules #scopes scopes #type-context types #host host - #seed (n/+ +1 seed) #expected expected + #seed (n/+ 1 seed) #expected expected #cursor cursor #extensions extensions #scope-type-vars scope-type-vars} (identifier$ ["" ($_ text/compose "__gensym__" prefix (nat/encode seed))]))} @@ -2948,7 +2948,7 @@ (Rec Self [Int (List Self)])")]) ({(#Cons [_ (#Identifier "" name)] (#Cons body #Nil)) - (let' [body' (replace-syntax (list [name (` (#.Apply (~ (make-parameter +1)) (~ (make-parameter +0))))]) + (let' [body' (replace-syntax (list [name (` (#.Apply (~ (make-parameter 1)) (~ (make-parameter 0))))]) (update-parameters body))] (return (list (` (#.Apply .Nothing (#.UnivQ #.Nil (~ body'))))))) @@ -3117,7 +3117,7 @@ (list [(tag$ ["lux" "doc"]) (text$ "## The pattern-matching macro. ## Allows the usage of macros within the patterns to provide custom syntax. - (case (: (List Int) (list 1 2 3)) + (case (: (List Int) (list +1 +2 +3)) (#Cons x (#Cons y (#Cons z #Nil))) (#Some ($_ i/* x y z)) @@ -3136,7 +3136,7 @@ (list [(tag$ ["lux" "doc"]) (text$ "## Macro-expanding patterns. ## It's a special macro meant to be used with 'case'. - (case (: (List Int) (list 1 2 3)) + (case (: (List Int) (list +1 +2 +3)) (^ (list x y z)) (#Some ($_ i/* x y z)) @@ -3209,7 +3209,7 @@ (op x y))")]) (case tokens (^ (list [_ (#Tuple bindings)] body)) - (if (multiple? +2 (list/size bindings)) + (if (multiple? 2 (list/size bindings)) (|> bindings as-pairs list/reverse (list/fold (: (-> [Code Code] Code Code) (function' [lr body'] @@ -3353,7 +3353,7 @@ (def: branching-exponent Int - 5)")]) + +5)")]) (let [[export? tokens'] (export^ tokens) parts (: (Maybe [Code (List Code) (Maybe Code) Code (List [Code Code])]) (case tokens' @@ -3573,7 +3573,7 @@ (def: (index-of part text) (-> Text Text (Maybe Nat)) - ("lux text index" text part +0)) + ("lux text index" text part 0)) (def: (last-index-of' part part-size since text) (-> Text Nat Nat Text (Maybe Nat)) @@ -3586,7 +3586,7 @@ (def: (last-index-of part text) (-> Text Text (Maybe Nat)) - (case ("lux text index" text part +0) + (case ("lux text index" text part 0) (#Some since) (last-index-of' part ("lux text size" part) since text) @@ -3610,9 +3610,9 @@ (macro: (default tokens state) {#.doc "## Allows you to provide a default value that will be used ## if a (Maybe x) value turns out to be #.None. - (default 20 (#.Some 10)) => 10 + (default +20 (#.Some +10)) => +10 - (default 20 #.None) => 20"} + (default +20 #.None) => +20"} (case tokens (^ (list else maybe)) (let [g!temp (: Code [dummy-cursor (#Identifier ["" ""])]) @@ -3635,10 +3635,10 @@ (#Some idx) (list& (default (error! "UNDEFINED") - (clip2 +0 idx input)) + (clip2 0 idx input)) (text/split splitter (default (error! "UNDEFINED") - (clip1 (n/+ +1 idx) input)))))) + (clip1 (n/+ 1 idx) input)))))) (def: (nth idx xs) (All [a] @@ -3648,9 +3648,9 @@ #None (#Cons x xs') - (if (n/= +0 idx) + (if (n/= 0 idx) (#Some x) - (nth (n/- +1 idx) xs') + (nth (n/- 1 idx) xs') ))) (def: (beta-reduce env type) @@ -4132,7 +4132,7 @@ (def: (split at x) (-> Nat Text (Maybe [Text Text])) - (case [(..clip2 +0 at x) (..clip1 at x)] + (case [(..clip2 0 at x) (..clip1 at x)] [(#.Some pre) (#.Some post)] (#.Some [pre post]) @@ -4170,38 +4170,38 @@ (#Some found) (if (n/= ups found) - (count-ups (n/+ +1 ups) input) + (count-ups (n/+ 1 ups) input) ups))) (def: (list/drop amount a+) (All [a] (-> Nat (List a) (List a))) (case [amount a+] - (^or [+0 _] [_ #Nil]) + (^or [0 _] [_ #Nil]) a+ [_ (#Cons _ a+')] - (list/drop (n/- +1 amount) a+'))) + (list/drop (n/- 1 amount) a+'))) (def: (clean-module nested? relative-root module) (-> Bit Text Text (Meta Text)) - (case (count-ups +0 module) - +0 + (case (count-ups 0 module) + 0 (return (if nested? ($_ "lux text concat" relative-root "/" module) module)) ups (let [parts (text/split "/" relative-root)] - (if (n/< (list/size parts) (n/- +1 ups)) + (if (n/< (list/size parts) (n/- 1 ups)) (let [prefix (|> parts list/reverse - (list/drop (n/- +1 ups)) + (list/drop (n/- 1 ups)) list/reverse (interpose "/") text/join) clean (|> module (clip1 ups) (default (error! "UNDEFINED"))) output (case ("lux text size" clean) - +0 prefix + 0 prefix _ ($_ text/compose prefix "/" clean))] (return output)) (fail ($_ text/compose @@ -4545,7 +4545,7 @@ (n/odd? num) \"odd\" ## else-branch \"???\")"} - (if (n/= +0 (n/% +2 (list/size tokens))) + (if (n/= 0 (n/% 2 (list/size tokens))) (fail "cond requires an uneven number of arguments.") (case (list/reverse tokens) (^ (list& else branches')) @@ -4563,14 +4563,14 @@ (All [a] (-> Nat (List a) (List [Nat a]))) (case xs (#Cons x xs') - (#Cons [idx x] (enumerate' (n/+ +1 idx) xs')) + (#Cons [idx x] (enumerate' (n/+ 1 idx) xs')) #Nil #Nil)) (def: (enumerate xs) (All [a] (-> (List a) (List [Nat a]))) - (enumerate' +0 xs)) + (enumerate' 0 xs)) (macro: #export (get@ tokens) {#.doc "## Accesses the value of a record at a given tag. @@ -4872,7 +4872,7 @@ (:: Codec<Text,Int> encode) ## Also allows using that value as a function. - (:: Codec<Text,Int> encode 123)"} + (:: Codec<Text,Int> encode +123)"} (case tokens (^ (list struct [_ (#Identifier member)])) (return (list (` (let [(^open ".") (~ struct)] (~ (identifier$ member)))))) @@ -5176,7 +5176,7 @@ [(def: #export <name> {#.doc <doc>} (All [s] (-> (I64 s) (I64 s))) - (|>> (<special> +1)))] + (|>> (<special> 1)))] [inc "lux i64 +" "Increment function."] [dec "lux i64 -" "Decrement function."] @@ -5199,7 +5199,7 @@ (def: (repeat n x) (All [a] (-> Int a (List a))) - (if (i/> 0 n) + (if (i/> +0 n) (#Cons x (repeat (i/+ -1 n) x)) #Nil)) @@ -5289,9 +5289,9 @@ ## For Example: (doc \"Allows arbitrary looping, using the \\\"recur\\\" form to re-start the loop. Can be used in monadic code to create monadic loops.\" - (loop [count 0 + (loop [count +0 x init] - (if (< 10 count) + (if (< +10 count) (recur (inc count) (f x)) x)))"} (return (list (` [(~ cursor-code) @@ -5354,17 +5354,17 @@ (macro: #export (loop tokens) {#.doc (doc "Allows arbitrary looping, using the \"recur\" form to re-start the loop." "Can be used in monadic code to create monadic loops." - (loop [count 0 + (loop [count +0 x init] - (if (< 10 count) + (if (< +10 count) (recur (inc count) (f x)) x)) "Loops can also be given custom names." (loop my-loop - [count 0 + [count +0 x init] - (if (< 10 count) + (if (< +10 count) (my-loop (inc count) (f x)) x)))} (let [?params (case tokens @@ -5497,14 +5497,14 @@ [(bit #1) "#1" [_ (#.Bit #1)]] [(bit #0) "#0" [_ (#.Bit #0)]] - [(int 123) "123" [_ (#.Int 123)]] - [(frac 123.0) "123.0" [_ (#.Frac 123.0)]] + [(int +123) "+123" [_ (#.Int +123)]] + [(frac +123.0) "+123.0" [_ (#.Frac +123.0)]] [(text "\n") "\"\\n\"" [_ (#.Text "\n")]] [(tag ["yolo" "lol"]) "#yolo.lol" [_ (#.Tag ["yolo" "lol"])]] [(identifier ["yolo" "lol"]) "yolo.lol" [_ (#.Identifier ["yolo" "lol"])]] - [(form (list (bit #1) (int 123))) "(#1 123)" (^ [_ (#.Form (list [_ (#.Bit #1)] [_ (#.Int 123)]))])] - [(tuple (list (bit #1) (int 123))) "[#1 123]" (^ [_ (#.Tuple (list [_ (#.Bit #1)] [_ (#.Int 123)]))])] - [(record (list [(bit #1) (int 123)])) "{#1 123}" (^ [_ (#.Record (list [[_ (#.Bit #1)] [_ (#.Int 123)]]))])] + [(form (list (bit #1) (int +123))) "(#1 +123)" (^ [_ (#.Form (list [_ (#.Bit #1)] [_ (#.Int +123)]))])] + [(tuple (list (bit #1) (int +123))) "[#1 +123]" (^ [_ (#.Tuple (list [_ (#.Bit #1)] [_ (#.Int +123)]))])] + [(record (list [(bit #1) (int +123)])) "{#1 +123}" (^ [_ (#.Record (list [[_ (#.Bit #1)] [_ (#.Int +123)]]))])] [(local-tag "lol") "#lol" [_ (#.Tag ["" "lol"])]] [(local-identifier "lol") "lol" [_ (#.Identifier ["" "lol"])]] )] @@ -5715,8 +5715,8 @@ (-> <type> Bit) (not (<even> n)))] - [Nat n/even? n/odd? n/% n/= +0 +2] - [Int i/even? i/odd? i/% i/= 0 2]) + [Nat n/even? n/odd? n/% n/= 0 2] + [Int i/even? i/odd? i/% i/= +0 +2]) (def: (get-scope-type-vars state) (Meta (List Nat)) @@ -5735,17 +5735,17 @@ #None (#Cons x xs') - (if (n/= +0 idx) + (if (n/= 0 idx) (#Some x) (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." - "In the example below, +0 corresponds to the 'a' variable." + "In the example below, 0 corresponds to the 'a' variable." (def: #export (from-list list) (All [a] (-> (List a) (Row a))) (list/fold add - (: (Row ($ +0)) + (: (Row ($ 0)) empty) list)))} (case tokens @@ -5765,11 +5765,11 @@ (def: #export (is? reference sample) {#.doc (doc "Tests whether the 2 values are identical (not just \"equal\")." "This one should succeed:" - (let [value 5] + (let [value +5] (is? value value)) "This one should fail:" - (is? 5 (i/+ 2 3)))} + (is? +5 (i/+ +2 +3)))} (All [a] (-> a a Bit)) ("lux is" reference sample)) @@ -5777,7 +5777,7 @@ {#.doc (doc "Allows you to simultaneously bind and de-structure a value." (def: (hash (^@ set [Hash<a> _])) (list/fold (function (_ elem acc) (n/+ (:: Hash<a> hash elem) acc)) - +0 + 0 (to-list set))))} (case tokens (^ (list& [_meta (#Form (list [_ (#Identifier ["" name])] pattern))] body branches)) @@ -5792,7 +5792,7 @@ (macro: #export (^|> tokens) {#.doc (doc "Pipes the value being pattern-matched against prior to binding it to a variable." (case input - (^|> value [inc (n/% +10) (n/max +1)]) + (^|> value [inc (n/% 10) (n/max 1)]) (foo value)))} (case tokens (^ (list& [_meta (#Form (list [_ (#Identifier ["" name])] [_ (#Tuple steps)]))] body branches)) @@ -5807,7 +5807,7 @@ (macro: #export (:assume tokens) {#.doc (doc "Coerces the given expression to the type of whatever is expected." - (: Dinosaur (:assume (list 1 2 3))))} + (: Dinosaur (:assume (list +1 +2 +3))))} (case tokens (^ (list expr)) (do Monad<Meta> @@ -5833,7 +5833,7 @@ (macro: #export (:of tokens) {#.doc (doc "Generates the type corresponding to a given definition or variable." - (let [my-num (: Int 123)] + (let [my-num (: Int +123)] (:of my-num)) "==" Int)} @@ -5947,8 +5947,8 @@ (macro: #export (char tokens compiler) (case tokens (^multi (^ (list [_ (#Text input)])) - (n/= +1 ("lux text size" input))) - (|> ("lux text char" input +0) + (n/= 1 ("lux text size" input))) + (|> ("lux text char" input 0) (default (undefined)) nat$ list [compiler] #Right) @@ -6152,8 +6152,8 @@ (def: #export (i/mod param subject) (All [m] (-> Int Int Int)) (let [raw (i/% param subject)] - (if (i/< 0 raw) - (let [shift (if (i/< 0 param) i/- i/+)] + (if (i/< +0 raw) + (let [shift (if (i/< +0 param) i/- i/+)] (|> raw (shift param))) raw))) @@ -6170,21 +6170,21 @@ (def: to-significand (-> (I64 Any) Frac) - (|>> ("lux i64 logical-right-shift" +11) + (|>> ("lux i64 logical-right-shift" 11) int-to-frac)) (def: rev-denominator Frac (to-significand -1)) (def: #export (frac-to-rev input) (-> Frac Rev) - (let [abs (if (f/< 0.0 input) + (let [abs (if (f/< +0.0 input) (f/* -1.0 input) input)] (|> abs - (f/% 1.0) + (f/% +1.0) (f/* rev-denominator) frac-to-int - ("lux i64 left-shift" +11)))) + ("lux i64 left-shift" 11)))) (def: #export rev-to-frac (-> Rev Frac) diff --git a/stdlib/source/lux/compiler/default/cache.lux b/stdlib/source/lux/compiler/default/cache.lux index 1b5f595fd..1770b4a82 100644 --- a/stdlib/source/lux/compiler/default/cache.lux +++ b/stdlib/source/lux/compiler/default/cache.lux @@ -18,7 +18,7 @@ (Format Module) ($_ _.and ## #module-hash - (_.ignore +0) + (_.ignore 0) ## #module-aliases (_.list ..alias) ## #definitions diff --git a/stdlib/source/lux/compiler/default/init.lux b/stdlib/source/lux/compiler/default/init.lux index cac69ab89..af31e03a4 100644 --- a/stdlib/source/lux/compiler/default/init.lux +++ b/stdlib/source/lux/compiler/default/init.lux @@ -6,20 +6,20 @@ (def: #export (cursor file) (-> Text Cursor) - [file +1 +0]) + [file 1 0]) (def: #export (source file code) (-> Text Text Source) - [(cursor file) +0 code]) + [(cursor file) 0 code]) (def: dummy-source Source - [.dummy-cursor +0 ""]) + [.dummy-cursor 0 ""]) (def: #export type-context Type-Context - {#.ex-counter +0 - #.var-counter +0 + {#.ex-counter 0 + #.var-counter 0 #.var-bindings (list)}) (`` (def: #export info @@ -46,7 +46,7 @@ #.scopes (list) #.type-context ..type-context #.expected #.None - #.seed +0 + #.seed 0 #.scope-type-vars (list) #.extensions [] #.host host}) diff --git a/stdlib/source/lux/compiler/default/name.lux b/stdlib/source/lux/compiler/default/name.lux index 50240a801..ddbf9ee8f 100644 --- a/stdlib/source/lux/compiler/default/name.lux +++ b/stdlib/source/lux/compiler/default/name.lux @@ -36,7 +36,7 @@ (def: #export (normalize name) (-> Text Text) (let [name/size (text.size name)] - (loop [idx +0 + (loop [idx 0 output ""] (if (n/< name/size idx) (recur (inc idx) diff --git a/stdlib/source/lux/compiler/default/phase/analysis.lux b/stdlib/source/lux/compiler/default/phase/analysis.lux index 182e3c321..cbd447d46 100644 --- a/stdlib/source/lux/compiler/default/phase/analysis.lux +++ b/stdlib/source/lux/compiler/default/phase/analysis.lux @@ -107,7 +107,7 @@ (n/= (dec size) tag)) (template: #export (no-op value) - (|> +1 #reference.Local #reference.Variable #..Reference + (|> 1 #reference.Local #reference.Variable #..Reference (#..Function (list)) (#..Apply value))) @@ -117,11 +117,11 @@ (let [left (function.constant (|>> #.Left #Sum <structure>)) right (|>> #.Right #Sum <structure>)] (if (last? size tag) - (if (n/= +1 tag) + (if (n/= 1 tag) (right value) (list/fold left (right value) - (list.n/range +0 (n/- +2 tag)))) + (list.n/range 0 (n/- 2 tag)))) (list/fold left (case value (<structure> (#Sum _)) @@ -129,7 +129,7 @@ _ value) - (list.n/range +0 tag)))))] + (list.n/range 0 tag)))))] [sum-analysis Analysis #Structure no-op] [sum-pattern Pattern #Complex id] @@ -174,7 +174,7 @@ (do-template [<name> <type> <tag>] [(def: #export (<name> value) (-> <type> (Maybe (Variant <type>))) - (loop [lefts +0 + (loop [lefts 0 variantA value] (case variantA (<tag> (#Sum (#.Left valueA))) @@ -238,13 +238,13 @@ (def: fresh-bindings (All [k v] (Bindings k v)) - {#.counter +0 + {#.counter 0 #.mappings (list)}) (def: fresh-scope Scope {#.name (list) - #.inner +0 + #.inner 0 #.locals fresh-bindings #.captured fresh-bindings}) diff --git a/stdlib/source/lux/compiler/default/phase/analysis/case/coverage.lux b/stdlib/source/lux/compiler/default/phase/analysis/case/coverage.lux index 24ded5476..df09bb0ec 100644 --- a/stdlib/source/lux/compiler/default/phase/analysis/case/coverage.lux +++ b/stdlib/source/lux/compiler/default/phase/analysis/case/coverage.lux @@ -19,11 +19,11 @@ (def: cases (-> (Maybe Nat) Nat) - (|>> (maybe.default +0))) + (|>> (maybe.default 0))) (def: (variant sum-side) (-> (Either Pattern Pattern) (Variant Pattern)) - (loop [lefts +0 + (loop [lefts 0 variantP sum-side] (case variantP (#.Left valueP) diff --git a/stdlib/source/lux/compiler/default/phase/analysis/inference.lux b/stdlib/source/lux/compiler/default/phase/analysis/inference.lux index 91e28a4ca..c96d0457c 100644 --- a/stdlib/source/lux/compiler/default/phase/analysis/inference.lux +++ b/stdlib/source/lux/compiler/default/phase/analysis/inference.lux @@ -70,7 +70,7 @@ (^template [<tag>] (<tag> env quantified) (<tag> (list/map (replace parameter-idx replacement) env) - (replace (n/+ +2 parameter-idx) replacement quantified))) + (replace (n/+ 2 parameter-idx) replacement quantified))) ([#.UnivQ] [#.ExQ]) @@ -199,7 +199,7 @@ ## Turns a variant type into the kind of function type suitable for inference. (def: #export (variant tag expected-size inferT) (-> Nat Nat Type (Operation Type)) - (loop [depth +0 + (loop [depth 0 currentT inferT] (case currentT (#.Named name unnamedT) @@ -224,9 +224,9 @@ (n/< boundary tag))) (case (list.nth tag cases) (#.Some caseT) - (operation/wrap (if (n/= +0 depth) + (operation/wrap (if (n/= 0 depth) (type.function (list caseT) currentT) - (let [replace' (replace (|> depth dec (n/* +2)) inferT)] + (let [replace' (replace (|> depth dec (n/* 2)) inferT)] (type.function (list (replace' caseT)) (replace' currentT))))) @@ -238,9 +238,9 @@ (n/= boundary tag) (let [caseT (type.variant (list.drop boundary cases))] - (operation/wrap (if (n/= +0 depth) + (operation/wrap (if (n/= 0 depth) (type.function (list caseT) currentT) - (let [replace' (replace (|> depth dec (n/* +2)) inferT)] + (let [replace' (replace (|> depth dec (n/* 2)) inferT)] (type.function (list (replace' caseT)) (replace' currentT)))))) diff --git a/stdlib/source/lux/compiler/default/phase/analysis/scope.lux b/stdlib/source/lux/compiler/default/phase/analysis/scope.lux index a3f7e926c..2c34e7a44 100644 --- a/stdlib/source/lux/compiler/default/phase/analysis/scope.lux +++ b/stdlib/source/lux/compiler/default/phase/analysis/scope.lux @@ -43,7 +43,7 @@ (def: (captured name scope) (-> Text Scope (Maybe [Type Variable])) - (loop [idx +0 + (loop [idx 0 mappings (get@ [#.captured #.mappings] scope)] (case mappings #.Nil @@ -133,7 +133,7 @@ (do-template [<name> <val-type>] [(def: <name> (Bindings Text [Type <val-type>]) - {#.counter +0 + {#.counter 0 #.mappings (list)})] [init-locals Nat] @@ -143,7 +143,7 @@ (def: (scope parent-name child-name) (-> (List Text) Text Scope) {#.name (list& child-name parent-name) - #.inner +0 + #.inner 0 #.locals init-locals #.captured init-captured}) diff --git a/stdlib/source/lux/compiler/default/phase/analysis/structure.lux b/stdlib/source/lux/compiler/default/phase/analysis/structure.lux index e4d6159fc..f894679ef 100644 --- a/stdlib/source/lux/compiler/default/phase/analysis/structure.lux +++ b/stdlib/source/lux/compiler/default/phase/analysis/structure.lux @@ -181,7 +181,7 @@ ## the tuple represents the expectations of the user. ## If the type is for a 3-tuple, but a 5-tuple is provided, it ## is assumed that the user intended the following layout: - ## [0, 1, [2, 3, 4]] + ## [+0, +1, [+2, +3, +4]] ## but that, for whatever reason, it was written in a flat ## way. [tailT tailC] @@ -312,7 +312,7 @@ _ (if (n/= size-ts size-record) (wrap []) (///.throw record-size-mismatch [size-ts size-record recordT record])) - #let [tuple-range (list.n/range +0 (dec size-ts)) + #let [tuple-range (list.n/range 0 (dec size-ts)) tag->idx (dict.from-list name.Hash<Name> (list.zip2 tag-set tuple-range))] idx->val (monad.fold @ (function (_ [key val] idx->val) diff --git a/stdlib/source/lux/compiler/default/phase/extension/analysis/common.lux b/stdlib/source/lux/compiler/default/phase/extension/analysis/common.lux index 2817fd55d..d4e94a36f 100644 --- a/stdlib/source/lux/compiler/default/phase/extension/analysis/common.lux +++ b/stdlib/source/lux/compiler/default/phase/extension/analysis/common.lux @@ -82,7 +82,7 @@ (wrap (#analysis.Extension extension-name (list opA)))) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: lux::in-module Handler @@ -108,7 +108,7 @@ ## (analyse valueC))) ## _ -## (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)]))))] +## (////.throw bundle.incorrect-arity [extension-name 2 (list.size args)]))))] ## [lux::check (:coerce Type actualT)] ## [lux::coerce Any] @@ -126,7 +126,7 @@ (wrap valueA)) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: bundle::lux Bundle @@ -275,7 +275,7 @@ (wrap (#analysis.Extension extension-name (list initA)))) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: atom::read Handler @@ -315,7 +315,7 @@ (wrap (#analysis.Extension extension-name (list initA)))) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: box::read Handler diff --git a/stdlib/source/lux/compiler/default/phase/extension/analysis/host.jvm.lux b/stdlib/source/lux/compiler/default/phase/extension/analysis/host.jvm.lux index 7f63118ea..706d35e51 100644 --- a/stdlib/source/lux/compiler/default/phase/extension/analysis/host.jvm.lux +++ b/stdlib/source/lux/compiler/default/phase/extension/analysis/host.jvm.lux @@ -231,7 +231,7 @@ (wrap (#analysis.Extension extension-name (list arrayA)))) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: array::new Handler @@ -244,7 +244,7 @@ expectedT (///.lift macro.expected-type) [level elem-class] (: (Operation [Nat Text]) (loop [analysisT expectedT - level +0] + level 0] (case analysisT (#.Apply inputT funcT) (case (type.apply (list inputT) funcT) @@ -262,7 +262,7 @@ _ (////.throw non-array expectedT)))) - _ (if (n/> +0 level) + _ (if (n/> 0 level) (wrap []) (////.throw non-array expectedT))] (wrap (#analysis.Extension extension-name (list (analysis.nat (dec level)) @@ -270,7 +270,7 @@ lengthA)))) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: (check-jvm objectT) (-> Type (Operation Text)) @@ -344,7 +344,7 @@ (wrap (#analysis.Extension extension-name (list (analysis.text elem-class) idxA arrayA)))) _ - (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 2 (list.size args)])))) (def: array::write Handler @@ -366,7 +366,7 @@ (wrap (#analysis.Extension extension-name (list (analysis.text elem-class) idxA valueA arrayA)))) _ - (////.throw bundle.incorrect-arity [extension-name +3 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 3 (list.size args)])))) (def: bundle::array Bundle @@ -389,7 +389,7 @@ (wrap (#analysis.Extension extension-name (list)))) _ - (////.throw bundle.incorrect-arity [extension-name +0 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 0 (list.size args)])))) (def: object::null? Handler @@ -404,7 +404,7 @@ (wrap (#analysis.Extension extension-name (list objectA)))) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: object::synchronized Handler @@ -419,7 +419,7 @@ (wrap (#analysis.Extension extension-name (list monitorA exprA)))) _ - (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 2 (list.size args)])))) (host.import: java/lang/Object (equals [Object] boolean)) @@ -516,7 +516,7 @@ (wrap (#analysis.Extension extension-name (list exceptionA)))) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: object::class Handler @@ -534,7 +534,7 @@ (////.throw bundle.invalid-syntax extension-name)) _ - (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 1 (list.size args)])))) (def: object::instance? Handler @@ -557,7 +557,7 @@ (////.throw bundle.invalid-syntax extension-name)) _ - (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 2 (list.size args)])))) (def: (java-type-to-class jvm-type) (-> java/lang/reflect/Type (Operation Text)) @@ -588,8 +588,8 @@ (host.instance? WildcardType java-type) (let [java-type (:coerce WildcardType java-type)] - (case [(array.read +0 (WildcardType::getUpperBounds [] java-type)) - (array.read +0 (WildcardType::getLowerBounds [] java-type))] + (case [(array.read 0 (WildcardType::getUpperBounds [] java-type)) + (array.read 0 (WildcardType::getLowerBounds [] java-type))] (^or [(#.Some bound) _] [_ (#.Some bound)]) (java-type-to-lux-type mappings bound) @@ -600,13 +600,13 @@ (let [java-type (:coerce (Class Object) java-type) class-name (Class::getName [] java-type)] (operation/wrap (case (array.size (Class::getTypeParameters [] java-type)) - +0 + 0 (#.Primitive class-name (list)) arity - (|> (list.n/range +0 (dec arity)) + (|> (list.n/range 0 (dec arity)) list.reverse - (list/map (|>> (n/* +2) inc #.Parameter)) + (list/map (|>> (n/* 2) inc #.Parameter)) (#.Primitive class-name) (type.univ-q arity))))) @@ -831,7 +831,7 @@ (////.throw bundle.invalid-syntax extension-name)) _ - (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 2 (list.size args)])))) (def: static::put Handler @@ -853,7 +853,7 @@ (////.throw bundle.invalid-syntax extension-name)) _ - (////.throw bundle.incorrect-arity [extension-name +3 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 3 (list.size args)])))) (def: virtual::get Handler @@ -872,7 +872,7 @@ (////.throw bundle.invalid-syntax extension-name)) _ - (////.throw bundle.incorrect-arity [extension-name +3 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 3 (list.size args)])))) (def: virtual::put Handler @@ -896,7 +896,7 @@ (////.throw bundle.invalid-syntax extension-name)) _ - (////.throw bundle.incorrect-arity [extension-name +4 (list.size args)])))) + (////.throw bundle.incorrect-arity [extension-name 4 (list.size args)])))) (def: (java-type-to-parameter type) (-> java/lang/reflect/Type (Operation Text)) @@ -970,11 +970,11 @@ (def: idx-to-parameter (-> Nat Type) - (|>> (n/* +2) inc #.Parameter)) + (|>> (n/* 2) inc #.Parameter)) (def: (type-vars amount offset) (-> Nat Nat (List Type)) - (if (n/= +0 amount) + (if (n/= 0 amount) (list) (|> (list.n/range offset (|> amount dec (n/+ offset))) (list/map idx-to-parameter)))) @@ -998,7 +998,7 @@ num-method-tvars (list.size method-tvars) all-tvars (list/compose owner-tvars method-tvars) num-all-tvars (list.size all-tvars) - owner-tvarsT (type-vars num-owner-tvars +0) + owner-tvarsT (type-vars num-owner-tvars 0) method-tvarsT (type-vars num-method-tvars num-owner-tvars) mappings (: Mappings (if (list.empty? all-tvars) @@ -1086,7 +1086,7 @@ num-owner-tvars (list.size owner-tvars) all-tvars (list/compose owner-tvars constructor-tvars) num-all-tvars (list.size all-tvars) - owner-tvarsT (type-vars num-owner-tvars +0) + owner-tvarsT (type-vars num-owner-tvars 0) constructor-tvarsT (type-vars num-all-tvars num-owner-tvars) mappings (: Mappings (if (list.empty? all-tvars) diff --git a/stdlib/source/lux/compiler/default/phase/synthesis.lux b/stdlib/source/lux/compiler/default/phase/synthesis.lux index 8deb48ba8..1dbbffd84 100644 --- a/stdlib/source/lux/compiler/default/phase/synthesis.lux +++ b/stdlib/source/lux/compiler/default/phase/synthesis.lux @@ -25,10 +25,10 @@ (def: #export init State - {#scope-arity +0 + {#scope-arity 0 #resolver fresh-resolver #direct? #0 - #locals +0}) + #locals 0}) (type: #export Primitive (#Bit Bit) diff --git a/stdlib/source/lux/compiler/default/phase/synthesis/expression.lux b/stdlib/source/lux/compiler/default/phase/synthesis/expression.lux index edb2cc034..241896e58 100644 --- a/stdlib/source/lux/compiler/default/phase/synthesis/expression.lux +++ b/stdlib/source/lux/compiler/default/phase/synthesis/expression.lux @@ -67,11 +67,11 @@ (do @ [arity //.scope-arity] (wrap (if (function.nested? arity) - (if (n/= +0 register) + (if (n/= 0 register) (|> (dec arity) - (list.n/range +1) + (list.n/range 1) (list/map (|>> //.variable/local)) - [(//.variable/local +0)] + [(//.variable/local 0)] //.function/apply) (#//.Reference (#reference.Variable (function.adjust arity #0 var)))) (#//.Reference (#reference.Variable var))))) diff --git a/stdlib/source/lux/compiler/default/phase/synthesis/function.lux b/stdlib/source/lux/compiler/default/phase/synthesis/function.lux index 397ca2449..eadcd52b0 100644 --- a/stdlib/source/lux/compiler/default/phase/synthesis/function.lux +++ b/stdlib/source/lux/compiler/default/phase/synthesis/function.lux @@ -20,7 +20,7 @@ (def: #export nested? (-> Arity Bit) - (n/> +1)) + (n/> 1)) (def: #export (adjust up-arity after? var) (-> Arity Bit Variable Variable) @@ -90,7 +90,7 @@ resolver //.resolver #let [function-arity (if direct? (inc arity) - +1) + 1) up-environment (if (nested? arity) (list/map (.function (_ closure) (case (dict.get closure resolver) @@ -107,7 +107,7 @@ (list) _ - (|> (list.size environment) dec (list.n/range +0) + (|> (list.size environment) dec (list.n/range 0) (list/map (|>> #reference.Foreign))))) resolver' (if (and (nested? function-arity) direct?) @@ -129,6 +129,6 @@ ..return)) _ - (|> (prepare function-arity +1 bodyS) - (maybe/map (|>> [up-environment +1] //.function/abstraction)) + (|> (prepare function-arity 1 bodyS) + (maybe/map (|>> [up-environment 1] //.function/abstraction)) ..return)))) diff --git a/stdlib/source/lux/compiler/default/phase/synthesis/loop.lux b/stdlib/source/lux/compiler/default/phase/synthesis/loop.lux index bfa69c7c6..e7db982d8 100644 --- a/stdlib/source/lux/compiler/default/phase/synthesis/loop.lux +++ b/stdlib/source/lux/compiler/default/phase/synthesis/loop.lux @@ -27,7 +27,7 @@ #.None #0)) (template: #export (self) - (#//.Reference (reference.local +0))) + (#//.Reference (reference.local 0))) (template: (recursive-apply args) (#//.Apply (self) args)) diff --git a/stdlib/source/lux/compiler/default/phase/translation.lux b/stdlib/source/lux/compiler/default/phase/translation.lux index f9b5dfbb4..f9d61c4af 100644 --- a/stdlib/source/lux/compiler/default/phase/translation.lux +++ b/stdlib/source/lux/compiler/default/phase/translation.lux @@ -76,12 +76,12 @@ (-> (Host expression statement) (..State anchor expression statement))) {#context {#scope-name "" - #inner-functions +0} + #inner-functions 0} #anchor #.None #host host #buffer #.None #artifacts (dict.new text.Hash<Text>) - #counter +0}) + #counter 0}) (def: #export (with-context expr) (All [anchor expression statement output] @@ -90,7 +90,7 @@ (function (_ [bundle state]) (let [[old-scope old-inner] (get@ #context state) new-scope (format old-scope "c___" (%i (.int old-inner)))] - (case (expr [bundle (set@ #context [new-scope +0] state)]) + (case (expr [bundle (set@ #context [new-scope 0] state)]) (#error.Success [[bundle' state'] output]) (#error.Success [[bundle' (set@ #context [old-scope (inc old-inner)] state')] [new-scope output]]) diff --git a/stdlib/source/lux/compiler/default/phase/translation/scheme/extension/common.jvm.lux b/stdlib/source/lux/compiler/default/phase/translation/scheme/extension/common.jvm.lux index fb03f3788..9952a754d 100644 --- a/stdlib/source/lux/compiler/default/phase/translation/scheme/extension/common.jvm.lux +++ b/stdlib/source/lux/compiler/default/phase/translation/scheme/extension/common.jvm.lux @@ -30,10 +30,10 @@ (syntax: (Vector {size s.nat} elemT) (wrap (list (` [(~+ (list.repeat size elemT))])))) -(type: #export Nullary (-> (Vector +0 Expression) Computation)) -(type: #export Unary (-> (Vector +1 Expression) Computation)) -(type: #export Binary (-> (Vector +2 Expression) Computation)) -(type: #export Trinary (-> (Vector +3 Expression) Computation)) +(type: #export Nullary (-> (Vector 0 Expression) Computation)) +(type: #export Unary (-> (Vector 1 Expression) Computation)) +(type: #export Binary (-> (Vector 2 Expression) Computation)) +(type: #export Trinary (-> (Vector 3 Expression) Computation)) (type: #export Variadic (-> (List Expression) Computation)) ## [Utils] @@ -55,12 +55,12 @@ ((~' wrap) ((~ g!extension) [(~+ g!input+)]))) (~' _) - (/////.throw bundle.incorrect-arity [(~ g!name) +1 (list.size (~ g!inputs))])))))))))) + (/////.throw bundle.incorrect-arity [(~ g!name) 1 (list.size (~ g!inputs))])))))))))) -(arity: nullary +0) -(arity: unary +1) -(arity: binary +2) -(arity: trinary +3) +(arity: nullary 0) +(arity: unary 1) +(arity: binary 2) +(arity: trinary 3) (def: #export (variadic extension) (-> Variadic Handler) @@ -91,17 +91,17 @@ (def: (bit::left-shift [subjectO paramO]) Binary - (_.arithmetic-shift/2 (_.remainder/2 (_.int 64) paramO) + (_.arithmetic-shift/2 (_.remainder/2 (_.int +64) paramO) subjectO)) (def: (bit::arithmetic-right-shift [subjectO paramO]) Binary - (_.arithmetic-shift/2 (|> paramO (_.remainder/2 (_.int 64)) (_.*/2 (_.int -1))) + (_.arithmetic-shift/2 (|> paramO (_.remainder/2 (_.int +64)) (_.*/2 (_.int -1))) subjectO)) (def: (bit::logical-right-shift [subjectO paramO]) Binary - (runtime.bit//logical-right-shift (_.remainder/2 (_.int 64) paramO) subjectO)) + (runtime.bit//logical-right-shift (_.remainder/2 (_.int +64) paramO) subjectO)) (def: bundle::bit Bundle @@ -209,7 +209,7 @@ (bundle.install "%" (binary int::%)) (bundle.install "=" (binary int::=)) (bundle.install "<" (binary int::<)) - (bundle.install "to-frac" (unary (|>> (_.//2 (_.float 1.0))))) + (bundle.install "to-frac" (unary (|>> (_.//2 (_.float +1.0))))) (bundle.install "char" (unary int::char))))) (def: bundle::frac @@ -302,7 +302,7 @@ (def: (atom::read atom) Unary - (_.vector-ref/2 atom (_.int 0))) + (_.vector-ref/2 atom (_.int +0))) (def: (atom::compare-and-swap [atomO oldO newO]) Trinary @@ -332,7 +332,7 @@ ## [[Processes]] (def: (process::parallelism-level []) Nullary - (_.int 1)) + (_.int +1)) (def: bundle::process Bundle diff --git a/stdlib/source/lux/compiler/default/phase/translation/scheme/function.jvm.lux b/stdlib/source/lux/compiler/default/phase/translation/scheme/function.jvm.lux index 113f6b325..d4316a0b5 100644 --- a/stdlib/source/lux/compiler/default/phase/translation/scheme/function.jvm.lux +++ b/stdlib/source/lux/compiler/default/phase/translation/scheme/function.jvm.lux @@ -70,14 +70,14 @@ (_.letrec (list [@function (_.lambda [(list) (#.Some @curried)] (_.let (list [@num-args (_.length/1 @curried)]) (<| (_.if (|> @num-args (_.=/2 arityO)) - (<| (_.let (list [(reference.local' +0) @function])) - (_.let-values (list [[(|> (list.n/range +0 (dec arity)) + (<| (_.let (list [(reference.local' 0) @function])) + (_.let-values (list [[(|> (list.n/range 0 (dec arity)) (list/map ..input)) #.None] (_.apply/2 (_.global "apply") (_.global "values") @curried)])) bodyO)) (_.if (|> @num-args (_.>/2 arityO)) - (let [arity-args (runtime.slice (_.int 0) arityO @curried) + (let [arity-args (runtime.slice (_.int +0) arityO @curried) output-func-args (runtime.slice arityO (|> @num-args (_.-/2 arityO)) @curried)] diff --git a/stdlib/source/lux/compiler/default/phase/translation/scheme/runtime.jvm.lux b/stdlib/source/lux/compiler/default/phase/translation/scheme/runtime.jvm.lux index 607d922e4..2ec83227d 100644 --- a/stdlib/source/lux/compiler/default/phase/translation/scheme/runtime.jvm.lux +++ b/stdlib/source/lux/compiler/default/phase/translation/scheme/runtime.jvm.lux @@ -58,19 +58,19 @@ (def: #export none Computation - (variant [+0 #0 ..unit])) + (variant [0 #0 ..unit])) (def: #export some (-> Expression Computation) - (|>> [+0 #1] ..variant)) + (|>> [0 #1] ..variant)) (def: #export left (-> Expression Computation) - (|>> [+0 #0] ..variant)) + (|>> [0 #0] ..variant)) (def: #export right (-> Expression Computation) - (|>> [+0 #1] ..variant)) + (|>> [0 #1] ..variant)) (def: declaration (s.Syntax [Text (List Text)]) @@ -114,14 +114,14 @@ (runtime: (slice offset length list) (<| (_.if (_.null?/1 list) list) - (_.if (|> offset (_.>/2 (_.int 0))) - (slice (|> offset (_.-/2 (_.int 1))) + (_.if (|> offset (_.>/2 (_.int +0))) + (slice (|> offset (_.-/2 (_.int +1))) length (_.cdr/1 list))) - (_.if (|> length (_.>/2 (_.int 0))) + (_.if (|> length (_.>/2 (_.int +0))) (_.cons/2 (_.car/1 list) (slice offset - (|> length (_.-/2 (_.int 1))) + (|> length (_.-/2 (_.int +1))) (_.cdr/1 list)))) _.nil)) @@ -157,7 +157,7 @@ (def: minimum-index-length (-> Expression Computation) - (|>> (_.+/2 (_.int 1)))) + (|>> (_.+/2 (_.int +1)))) (def: product-element (-> Expression Expression Computation) @@ -165,7 +165,7 @@ (def: (product-tail product) (-> Expression Computation) - (_.vector-ref/2 product (|> (_.length/1 product) (_.-/2 (_.int 1))))) + (_.vector-ref/2 product (|> (_.length/1 product) (_.-/2 (_.int +1))))) (def: (updated-index min-length product) (-> Expression Expression Computation) @@ -202,7 +202,7 @@ (_.begin (list (_.define @slice [(list) #.None] (_.make-vector/1 (|> @product_length (_.-/2 index)))) - (_.vector-copy!/5 @slice (_.int 0) product index @product_length) + (_.vector-copy!/5 @slice (_.int +0) product index @product_length) @slice))))))) (runtime: (sum//get sum last? wanted-tag) @@ -235,11 +235,11 @@ @@sum//get))) (runtime: (bit//logical-right-shift shift input) - (_.if (_.=/2 (_.int 0) shift) + (_.if (_.=/2 (_.int +0) shift) input (|> input (_.arithmetic-shift/2 (_.*/2 (_.int -1) shift)) - (_.bit-and/2 (_.int (hex "7FFFFFFFFFFFFFFF")))))) + (_.bit-and/2 (_.int (hex "+7FFFFFFFFFFFFFFF")))))) (def: runtime//bit Computation @@ -286,10 +286,10 @@ (runtime: (atom//compare-and-swap atom old new) (with-vars [@temp] - (_.let (list [@temp (_.vector-ref/2 atom (_.int 0))]) + (_.let (list [@temp (_.vector-ref/2 atom (_.int +0))]) (_.if (_.eq?/2 old @temp) (_.begin - (list (_.vector-set!/3 atom (_.int 0) new) + (list (_.vector-set!/3 atom (_.int +0) new) (_.bool #1))) (_.bool #0))))) @@ -300,7 +300,7 @@ (runtime: (box//write value box) (_.begin (list - (_.vector-set!/3 box (_.int 0) value) + (_.vector-set!/3 box (_.int +0) value) ..unit))) (def: runtime//box @@ -309,7 +309,7 @@ (runtime: (io//current-time _) (|> (_.apply/* (_.global "current-second") (list)) - (_.*/2 (_.int 1_000)) + (_.*/2 (_.int +1_000)) _.exact/1)) (def: runtime//io @@ -334,7 +334,7 @@ (_.set! process//incoming (_.cons/2 process process//incoming)))] (_.begin (list - (_.if (_.=/2 (_.int 0) milli-seconds) + (_.if (_.=/2 (_.int +0) milli-seconds) (process//future procedure) (with-vars [@start @process @now @ignored] (_.let (list [@start (io//current-time ..unit)]) diff --git a/stdlib/source/lux/compiler/default/reference.lux b/stdlib/source/lux/compiler/default/reference.lux index 086c72810..0bbeb2db5 100644 --- a/stdlib/source/lux/compiler/default/reference.lux +++ b/stdlib/source/lux/compiler/default/reference.lux @@ -31,10 +31,10 @@ (def: (hash var) (case var (#Local register) - (n/* +1 register) + (n/* 1 register) (#Foreign register) - (n/* +2 register)))) + (n/* 2 register)))) (do-template [<name> <family> <tag>] [(template: #export (<name> content) @@ -55,12 +55,12 @@ [constant #..Constant] ) -(def: #export self Reference (..local +0)) +(def: #export self Reference (..local 0)) (def: #export self? (-> Variable Bit) (|>> ..variable - (case> (^ (..local +0)) + (case> (^ (..local 0)) #1 _ diff --git a/stdlib/source/lux/compiler/default/repl/type.lux b/stdlib/source/lux/compiler/default/repl/type.lux index b4a8735d8..212c5bcb9 100644 --- a/stdlib/source/lux/compiler/default/repl/type.lux +++ b/stdlib/source/lux/compiler/default/repl/type.lux @@ -110,7 +110,7 @@ (n/= num-tags (list.size casesR+)))] (wrap (function (_ variantV) (loop [cases-left (list.zip3 tags - (list.n/range +0 (dec num-tags)) + (list.n/range 0 (dec num-tags)) casesR+) variantV variantV] (case cases-left diff --git a/stdlib/source/lux/compiler/default/syntax.lux b/stdlib/source/lux/compiler/default/syntax.lux index e06590f2e..5b20dcff5 100644 --- a/stdlib/source/lux/compiler/default/syntax.lux +++ b/stdlib/source/lux/compiler/default/syntax.lux @@ -64,7 +64,7 @@ [content (l.many (l.one-of new-line))] (wrap [(|> where (update@ #.line (n/+ (text.size content))) - (set@ #.column +0)) + (set@ #.column 0)) content])) )) @@ -78,7 +78,7 @@ _ (l.this new-line)] (wrap [(|> where (update@ #.line inc) - (set@ #.column +0)) + (set@ #.column 0)) comment]))) ## This is just a helper parser to find text which doesn't run into @@ -100,7 +100,7 @@ (do p.Monad<Parser> [_ (l.this "#(")] (loop [comment "" - where (update@ #.column (n/+ +2) where)] + where (update@ #.column (n/+ 2) where)] ($_ p.either ## These are normal chunks of commented text. (do @ @@ -115,7 +115,7 @@ (recur (format comment new-line) (|> where (update@ #.line inc) - (set@ #.column +0)))) + (set@ #.column 0)))) ## This is the rule for handling nested sub-comments. ## Ultimately, the whole comment is just treated as text ## (the comment must respect the syntax structure, but the @@ -129,7 +129,7 @@ ## Finally, this is the rule for closing the comment. (do @ [_ (l.this ")#")] - (wrap [(update@ #.column (n/+ +2) where) + (wrap [(update@ #.column (n/+ 2) where) comment])) )))) @@ -171,22 +171,22 @@ [code l.any] (case code ## Handle special cases. - "t" (wrap [+2 "\t"]) - "v" (wrap [+2 "\v"]) - "b" (wrap [+2 "\b"]) - "n" (wrap [+2 "\n"]) - "r" (wrap [+2 "\r"]) - "f" (wrap [+2 "\f"]) - "\"" (wrap [+2 "\""]) - "\\" (wrap [+2 "\\"]) + "t" (wrap [2 "\t"]) + "v" (wrap [2 "\v"]) + "b" (wrap [2 "\b"]) + "n" (wrap [2 "\n"]) + "r" (wrap [2 "\r"]) + "f" (wrap [2 "\f"]) + "\"" (wrap [2 "\""]) + "\\" (wrap [2 "\\"]) ## Handle unicode escapes. "u" (do p.Monad<Parser> - [code (l.between +1 +4 l.hexadecimal)] - (wrap (case (|> code (format "+") (:: number.Hex@Codec<Text,Nat> decode)) + [code (l.between 1 4 l.hexadecimal)] + (wrap (case (:: number.Hex@Codec<Text,Nat> decode code) (#.Right value) - [(n/+ +2 (text.size code)) (text.from-code value)] + [(n/+ 2 (text.size code)) (text.from-code value)] _ (undefined)))) @@ -207,6 +207,8 @@ (l.and l.decimal (l.some rich-digit))) +(def: sign^ (l.one-of "+-")) + (do-template [<name> <tag> <lexer> <codec>] [(def: #export (<name> where) (-> Cursor (l.Lexer [Cursor Code])) @@ -221,8 +223,7 @@ [where (<tag> value)]]))))] [int #.Int - (l.and (p.default "" (l.one-of "-")) - rich-digits^) + (l.and sign^ rich-digits^) number.Codec<Text,Int>] [rev #.Rev @@ -251,7 +252,7 @@ (update@ #.column (n/+ chars-consumed))) char])))) _ (l.this "\"") - #let [char (maybe.assume (text.nth +0 char))]] + #let [char (maybe.assume (text.nth 0 char))]] (wrap [(|> where' (update@ #.column inc)) [where (#.Nat char)]]))) @@ -259,8 +260,7 @@ (def: (normal-nat where) (-> Cursor (l.Lexer [Cursor Code])) (do p.Monad<Parser> - [chunk (l.and (l.one-of "+") - rich-digits^)] + [chunk rich-digits^] (case (:: number.Codec<Text,Nat> decode chunk) (#.Left error) (p.fail error) @@ -278,14 +278,14 @@ (-> Cursor (l.Lexer [Cursor Code])) (do p.Monad<Parser> [chunk ($_ l.and - (p.default "" (l.one-of "-")) + sign^ rich-digits^ (l.one-of ".") rich-digits^ (p.default "" ($_ l.and (l.one-of "eE") - (p.default "" (l.one-of "+-")) + sign^ rich-digits^)))] (case (:: number.Codec<Text,Frac> decode chunk) (#.Left error) @@ -317,9 +317,9 @@ _ (l.this? "/") denominator frac-ratio-fragment _ (p.assert "Denominator cannot be 0." - (not (f/= 0.0 denominator)))] + (not (f/= +0.0 denominator)))] (wrap (|> numerator - (f/* (if signed? -1.0 1.0)) + (f/* (if signed? -1.0 +1.0)) (f// denominator)))))] (wrap [(update@ #.column (n/+ (text.size chunk)) where) [where (#.Frac value)]]))) @@ -412,7 +412,7 @@ (recur (format text-read new-line) (|> where (update@ #.line inc) - (set@ #.column +0)) + (set@ #.column 0)) #1)))))] (wrap [where' [where (#.Text text-read)]]))) @@ -529,7 +529,7 @@ [_ (l.this current-module-mark) def-name name-part^] (wrap [[current-module def-name] - (n/+ +2 (text.size def-name))])) + (n/+ 2 (text.size def-name))])) ## If the name is prefixed by the mark, but no module ## part, the module is assumed to be "lux" (otherwise known as ## the 'prelude'). @@ -559,7 +559,7 @@ second-part] ($_ n/+ (text.size first-part) - +1 + 1 (text.size second-part))])) (wrap [["" first-part] (text.size first-part)]))))) @@ -569,7 +569,7 @@ (do p.Monad<Parser> [[value length] (p.after (l.this "#") (name^ current-module aliases))] - (wrap [(update@ #.column (|>> ($_ n/+ +1 length)) where) + (wrap [(update@ #.column (|>> ($_ n/+ 1 length)) where) [where (#.Tag value)]]))) (def: #export (identifier current-module aliases where) diff --git a/stdlib/source/lux/compiler/meta/io/archive.lux b/stdlib/source/lux/compiler/meta/io/archive.lux index 1c5924df7..1f0714b25 100644 --- a/stdlib/source/lux/compiler/meta/io/archive.lux +++ b/stdlib/source/lux/compiler/meta/io/archive.lux @@ -67,7 +67,7 @@ (#.Some ["" post]) (let [raw (text.replace-all (:: System<m> separator) "/" post)] (if (text.starts-with? "/" raw) - (text.clip' +1 raw) + (text.clip' 1 raw) (#.Some raw))) _ diff --git a/stdlib/source/lux/concurrency/actor.lux b/stdlib/source/lux/concurrency/actor.lux index 30924c86d..f6a6fbe0d 100644 --- a/stdlib/source/lux/concurrency/actor.lux +++ b/stdlib/source/lux/concurrency/actor.lux @@ -335,11 +335,11 @@ (if (list.empty? actor-vars) (list) (|> actor-vars list.size dec - (list.n/range +0) (list/map (|>> code.nat (~) ($) (`)))))) + (list.n/range 0) (list/map (|>> code.nat (~) ($) (`)))))) ref-replacements (|> (if (list.empty? actor-vars) (list) (|> actor-vars list.size dec - (list.n/range +0) (list/map (|>> code.nat (~) ($) (`))))) + (list.n/range 0) (list/map (|>> code.nat (~) ($) (`))))) (: (List Code)) (list.zip2 g!all-vars) (: (List [Code Code]))) diff --git a/stdlib/source/lux/concurrency/promise.lux b/stdlib/source/lux/concurrency/promise.lux index f84b659ff..7062c2082 100644 --- a/stdlib/source/lux/concurrency/promise.lux +++ b/stdlib/source/lux/concurrency/promise.lux @@ -155,7 +155,7 @@ (def: #export future {#.doc "Runs an I/O computation on its own process and returns a Promise that will eventually host its result."} (All [a] (-> (IO a) (Promise a))) - (schedule +0)) + (schedule 0)) (def: #export (delay time-millis value) {#.doc "Delivers a value after a certain period has passed."} diff --git a/stdlib/source/lux/concurrency/semaphore.lux b/stdlib/source/lux/concurrency/semaphore.lux index 3be7fb431..7b749ea60 100644 --- a/stdlib/source/lux/concurrency/semaphore.lux +++ b/stdlib/source/lux/concurrency/semaphore.lux @@ -33,8 +33,8 @@ [state (atom.read semaphore) #let [[ready? state'] (: [Bit State] (case (get@ #open-positions state) - +0 [#0 (update@ #waiting-list (|>> (#.Cons signal)) - state)] + 0 [#0 (update@ #waiting-list (|>> (#.Cons signal)) + state)] _ [#1 (update@ #open-positions dec state)]))] success? (atom.compare-and-swap state state' semaphore) @@ -79,7 +79,7 @@ (def: #export (mutex _) (-> Any Mutex) - (:abstraction (semaphore +1))) + (:abstraction (semaphore 1))) (def: (acquire mutex) (-> Mutex (Promise Any)) @@ -98,7 +98,7 @@ (wrap output))) ) -(def: #export limit (refinement.refinement (n/> +0))) +(def: #export limit (refinement.refinement (n/> 0))) (`` (type: #export Limit (~~ (refinement.type limit)))) (abstract: #export Barrier @@ -112,13 +112,13 @@ (def: #export (barrier limit) (-> Limit Barrier) (:abstraction {#limit limit - #count (atom.atom +0) - #start-turnstile (semaphore +0) - #end-turnstile (semaphore +0)})) + #count (atom.atom 0) + #start-turnstile (semaphore 0) + #end-turnstile (semaphore 0)})) (def: (un-block times turnstile) (-> Nat Semaphore (Promise Any)) - (loop [step +0] + (loop [step 0] (if (n/< times step) (do promise.Monad<Promise> [_ (signal turnstile)] @@ -138,7 +138,7 @@ (wait (get@ <turnstile> barrier))))] [start inc limit #start-turnstile] - [end dec +0 #end-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 211604dc7..23a059ae4 100644 --- a/stdlib/source/lux/control/comonad.lux +++ b/stdlib/source/lux/control/comonad.lux @@ -26,17 +26,17 @@ [a (F (CoFree F a))]) ## [Syntax] -(def: _cursor Cursor ["" +0 +0]) +(def: _cursor Cursor ["" 0 0]) (macro: #export (be tokens state) {#.doc (doc "A co-monadic parallel to the \"do\" macro." (let [square (function (_ n) (i/* n n))] (be CoMonad<Stream> - [inputs (iterate inc 2)] + [inputs (iterate inc +2)] (square (head inputs)))))} (case tokens (#.Cons comonad (#.Cons [_ (#.Tuple bindings)] (#.Cons body #.Nil))) - (if (|> bindings list.size (n/% +2) (n/= +0)) + (if (|> bindings list.size (n/% 2) (n/= 0)) (let [g!_ (: Code [_cursor (#.Identifier ["" " _ "])]) g!map (: Code [_cursor (#.Identifier ["" " map "])]) g!split (: Code [_cursor (#.Identifier ["" " split "])]) diff --git a/stdlib/source/lux/control/concatenative.lux b/stdlib/source/lux/control/concatenative.lux index ee4a78e13..0011c8956 100644 --- a/stdlib/source/lux/control/concatenative.lux +++ b/stdlib/source/lux/control/concatenative.lux @@ -129,7 +129,7 @@ (~ type) (|>> (~+ (list/map prepare commands)))))))) -(syntax: #export (apply {arity (|> s.nat (p.filter (.n/> +0)))}) +(syntax: #export (apply {arity (|> s.nat (p.filter (.n/> 0)))}) (with-gensyms [g! g!func g!stack g!output] (monad.do @ [g!inputs (|> (macro.gensym "input") (list.repeat arity) (monad.seq @))] @@ -141,14 +141,14 @@ [(~ g!stack) ((~ g!func) (~+ g!inputs))]))))))))) ## [Primitives] -(def: #export apply1 (apply +1)) -(def: #export apply2 (apply +2)) -(def: #export apply3 (apply +3)) -(def: #export apply4 (apply +4)) -(def: #export apply5 (apply +5)) -(def: #export apply6 (apply +6)) -(def: #export apply7 (apply +7)) -(def: #export apply8 (apply +8)) +(def: #export apply1 (apply 1)) +(def: #export apply2 (apply 2)) +(def: #export apply3 (apply 3)) +(def: #export apply4 (apply 4)) +(def: #export apply5 (apply 5)) +(def: #export apply6 (apply 6)) +(def: #export apply7 (apply 7)) +(def: #export apply8 (apply 8)) (def: #export (push x) (All [a] (-> a (=> [] [a]))) @@ -193,12 +193,12 @@ (def: #export ||L (All [a b] (=> [a] [(| a b)])) (function (_ [stack l]) - [stack (+0 l)])) + [stack (0 l)])) (def: #export ||R (All [a b] (=> [b] [(| a b)])) (function (_ [stack r]) - [stack (+1 r)])) + [stack (1 r)])) (do-template [<input> <output> <word> <func>] [(def: #export <word> diff --git a/stdlib/source/lux/control/contract.lux b/stdlib/source/lux/control/contract.lux index 72aefd174..065829f44 100644 --- a/stdlib/source/lux/control/contract.lux +++ b/stdlib/source/lux/control/contract.lux @@ -19,8 +19,8 @@ {#.doc (doc "Pre-conditions." "Given a test and an expression to run, only runs the expression if the test passes." "Otherwise, an error is raised." - (pre (i/= 4 (i/+ 2 2)) - (foo 123 456 789)))} + (pre (i/= +4 (i/+ +2 +2)) + (foo +123 +456 +789)))} (wrap (list (` (exec (assert! (~ (code.text (format "Pre-condition failed: " (%code test)))) (~ test)) (~ expr)))))) @@ -31,7 +31,7 @@ "If the predicate returns #1, returns the value of the expression." "Otherwise, an error is raised." (post i/even? - (i/+ 2 2)))} + (i/+ +2 +2)))} (with-gensyms [g!output] (wrap (list (` (let [(~ g!output) (~ expr)] (exec (assert! (~ (code.text (format "Post-condition failed: " (%code test)))) diff --git a/stdlib/source/lux/control/equivalence.lux b/stdlib/source/lux/control/equivalence.lux index dea0e3fa6..c10b0c295 100644 --- a/stdlib/source/lux/control/equivalence.lux +++ b/stdlib/source/lux/control/equivalence.lux @@ -15,10 +15,10 @@ (All [l r] (-> (Equivalence l) (Equivalence r) (Equivalence (| l r)))) (structure (def: (= a|b x|y) (case [a|b x|y] - [(+0 a) (+0 x)] + [(0 a) (0 x)] (:: left = a x) - [(+1 b) (+1 y)] + [(1 b) (1 y)] (:: right = b y) _ diff --git a/stdlib/source/lux/control/exception.lux b/stdlib/source/lux/control/exception.lux index 2a3cd92c0..d2e9c705d 100644 --- a/stdlib/source/lux/control/exception.lux +++ b/stdlib/source/lux/control/exception.lux @@ -116,7 +116,7 @@ (-> (List [Text Text]) Text) (let [largest-header-size (|> entries (list/map (|>> product.left text.size)) - (list/fold n/max +0))] + (list/fold n/max 0))] (|> entries (list/map (function (_ [header message]) (let [padding (|> " " diff --git a/stdlib/source/lux/control/monad.lux b/stdlib/source/lux/control/monad.lux index 09dd14237..36b2354fc 100644 --- a/stdlib/source/lux/control/monad.lux +++ b/stdlib/source/lux/control/monad.lux @@ -16,7 +16,7 @@ (def: (list/size xs) (All [a] (-> (List a) Nat)) - (loop [counter +0 + (loop [counter 0 xs xs] (case xs #.Nil @@ -53,7 +53,7 @@ join)) ## [Syntax] -(def: _cursor Cursor ["" +0 +0]) +(def: _cursor Cursor ["" 0 0]) (macro: #export (do tokens state) {#.doc (doc "Macro for easy concatenation of monadic operations." @@ -63,7 +63,7 @@ (wrap (f3 z))))} (case tokens (#.Cons monad (#.Cons [_ (#.Tuple bindings)] (#.Cons body #.Nil))) - (if (|> bindings list/size (n/% +2) (n/= +0)) + (if (|> bindings list/size (n/% 2) (n/= 0)) (let [g!_ (: Code [_cursor (#.Identifier ["" " _ "])]) g!map (: Code [_cursor (#.Identifier ["" " map "])]) g!join (: Code [_cursor (#.Identifier ["" " join "])]) diff --git a/stdlib/source/lux/control/parser.lux b/stdlib/source/lux/control/parser.lux index 32ef09784..c40de3373 100644 --- a/stdlib/source/lux/control/parser.lux +++ b/stdlib/source/lux/control/parser.lux @@ -119,11 +119,11 @@ (-> (Parser s a) (Parser s b) (Parser s (| a b)))) (function (_ tokens) (case (p1 tokens) - (#e.Success [tokens' x1]) (#e.Success [tokens' (+0 x1)]) + (#e.Success [tokens' x1]) (#e.Success [tokens' (0 x1)]) (#e.Error _) (run tokens (do Monad<Parser> [x2 p2] - (wrap (+1 x2)))) + (wrap (1 x2)))) ))) (def: #export (either pl pr) @@ -139,7 +139,7 @@ (def: #export (exactly n p) {#.doc "Parse exactly N times."} (All [s a] (-> Nat (Parser s a) (Parser s (List a)))) - (if (n/> +0 n) + (if (n/> 0 n) (do Monad<Parser> [x p xs (exactly (dec n) p)] @@ -157,7 +157,7 @@ (def: #export (at-most n p) {#.doc "Parse at most N times."} (All [s a] (-> Nat (Parser s a) (Parser s (List a)))) - (if (n/> +0 n) + (if (n/> 0 n) (function (_ input) (case (p input) (#e.Error msg) diff --git a/stdlib/source/lux/control/pipe.lux b/stdlib/source/lux/control/pipe.lux index ffdb78575..c23723f6d 100644 --- a/stdlib/source/lux/control/pipe.lux +++ b/stdlib/source/lux/control/pipe.lux @@ -16,12 +16,12 @@ (Syntax (List Code)) (s.tuple (p.some s.any))) -(syntax: #export (new> {tokens (p.at-least +2 s.any)}) +(syntax: #export (new> {tokens (p.at-least 2 s.any)}) {#.doc (doc "Ignores the piped argument, and begins a new pipe." - (|> 20 - (i/* 3) - (i/+ 4) - (new> 0 inc)))} + (|> +20 + (i/* +3) + (i/+ +4) + (new> +0 inc)))} (case (list.reverse tokens) (^ (list& _ r-body)) (wrap (list (` (|> (~+ (list.reverse r-body)))))) @@ -31,7 +31,7 @@ (syntax: #export (let> binding body prev) {#.doc (doc "Gives a name to the piped-argument, within the given expression." - (|> 5 + (|> +5 (let> X (i/+ X X))))} (wrap (list (` (let [(~ binding) (~ prev)] (~ body)))))) @@ -48,9 +48,9 @@ {branches (p.some (p.and body^ body^))}) {#.doc (doc "Branching for pipes." "Both the tests and the bodies are piped-code, and must be given inside a tuple." - (|> 5 - (cond> [i/even?] [(i/* 2)] - [i/odd?] [(i/* 3)] + (|> +5 + (cond> [i/even?] [(i/* +2)] + [i/odd?] [(i/* +3)] [(new> -1)])))} (with-gensyms [g!temp] (wrap (list (` (with-expansions @@ -71,8 +71,8 @@ prev) {#.doc (doc "Loops for pipes." "Both the testing and calculating steps are pipes and must be given inside tuples." - (|> 1 - (loop> [(i/< 10)] + (|> +1 + (loop> [(i/< +10)] [inc])))} (with-gensyms [g!temp] (wrap (list (` (loop [(~ g!temp) (~ prev)] @@ -85,10 +85,10 @@ prev) {#.doc (doc "Monadic pipes." "Each steps in the monadic computation is a pipe and must be given inside a tuple." - (|> 5 + (|> +5 (do> Monad<Identity> - [(i/* 3)] - [(i/+ 4)] + [(i/* +3)] + [(i/+ +4)] [inc])))} (with-gensyms [g!temp] (case (list.reverse steps) @@ -108,9 +108,9 @@ prev) {#.doc (doc "Non-updating pipes." "Will generate piped computations, but their results will not be used in the larger scope." - (|> 5 + (|> +5 (exec> [.nat %n log!]) - (i/* 10)))} + (i/* +10)))} (with-gensyms [g!temp] (wrap (list (` (let [(~ g!temp) (~ prev)] (exec (|> (~ g!temp) (~+ body)) @@ -120,11 +120,11 @@ prev) {#.doc (doc "Parallel branching for pipes." "Allows to run multiple pipelines for a value and gives you a tuple of the outputs." - (|> 5 - (tuple> [(i/* 10)] - [dec (i// 2)] + (|> +5 + (tuple> [(i/* +10)] + [dec (i// +2)] [Int/encode])) - "Will become: [50 2 \"5\"]")} + "Will become: [+50 +2 \"+5\"]")} (with-gensyms [g!temp] (wrap (list (` (let [(~ g!temp) (~ prev)] [(~+ (list/map (function (_ body) (` (|> (~ g!temp) (~+ body)))) @@ -134,17 +134,17 @@ prev) {#.doc (doc "Pattern-matching for pipes." "The bodies of each branch are NOT pipes; just regular values." - (|> 5 - (case> 0 "zero" - 1 "one" - 2 "two" - 3 "three" - 4 "four" - 5 "five" - 6 "six" - 7 "seven" - 8 "eight" - 9 "nine" + (|> +5 + (case> +0 "zero" + +1 "one" + +2 "two" + +3 "three" + +4 "four" + +5 "five" + +6 "six" + +7 "seven" + +8 "eight" + +9 "nine" _ "???")))} (wrap (list (` (case (~ prev) (~+ (list/join (list/map (function (_ [pattern body]) (list pattern body)) diff --git a/stdlib/source/lux/control/writer.lux b/stdlib/source/lux/control/writer.lux index a93242297..4007cb6cb 100644 --- a/stdlib/source/lux/control/writer.lux +++ b/stdlib/source/lux/control/writer.lux @@ -60,7 +60,7 @@ (def: (join MlMla) (do Monad<M> [## TODO: Remove once new-luxc is the standard compiler. - [l1 Mla] (: (($ +1) (Writer ($ +0) (($ +1) (Writer ($ +0) ($ +2))))) + [l1 Mla] (: (($ 1) (Writer ($ 0) (($ 1) (Writer ($ 0) ($ 2))))) MlMla) ## [l1 Mla] MlMla [l2 a] Mla] diff --git a/stdlib/source/lux/data/bit.lux b/stdlib/source/lux/data/bit.lux index 65bfad034..026f8bcab 100644 --- a/stdlib/source/lux/data/bit.lux +++ b/stdlib/source/lux/data/bit.lux @@ -18,8 +18,8 @@ (def: eq Equivalence<Bit>) (def: (hash value) (case value - #1 +1 - #0 +0))) + #1 1 + #0 0))) (do-template [<name> <identity> <op>] [(structure: #export <name> (Monoid Bit) diff --git a/stdlib/source/lux/data/collection/array.lux b/stdlib/source/lux/data/collection/array.lux index 1a9e191a8..1d64511a9 100644 --- a/stdlib/source/lux/data/collection/array.lux +++ b/stdlib/source/lux/data/collection/array.lux @@ -38,7 +38,7 @@ (All [a] (-> Nat Nat (Array a) Nat (Array a) (Array a))) - (if (n/= +0 length) + (if (n/= 0 length) dest-array (list/fold (function (_ offset target) (case (read (n/+ offset src-start) src-array) @@ -48,7 +48,7 @@ (#.Some value) (write (n/+ offset dest-start) value target))) dest-array - (list.n/range +0 (dec length))))) + (list.n/range 0 (dec length))))) (def: #export (occupied array) {#.doc "Finds out how many cells in an array are occupied."} @@ -60,7 +60,7 @@ (#.Some _) (inc count))) - +0 + 0 (list.indices (size array)))) (def: #export (vacant array) @@ -87,7 +87,7 @@ (All [a] (-> (-> a Bit) (Array a) (Maybe a))) (let [arr-size (size xs)] - (loop [idx +0] + (loop [idx 0] (if (n/< arr-size idx) (case (read idx xs) #.None @@ -104,7 +104,7 @@ (All [a] (-> (-> Nat a Bit) (Array a) (Maybe [Nat a]))) (let [arr-size (size xs)] - (loop [idx +0] + (loop [idx 0] (if (n/< arr-size idx) (case (read idx xs) #.None @@ -133,10 +133,10 @@ (All [a] (-> (List a) (Array a))) (product.right (list/fold (function (_ x [idx arr]) [(inc idx) (write idx x arr)]) - [+0 (new (list.size xs))] + [0 (new (list.size xs))] xs))) -(def: underflow Nat (dec +0)) +(def: underflow Nat (dec 0)) (def: #export (to-list array) (All [a] (-> (Array a) (List a))) @@ -170,23 +170,23 @@ _ #0))) #1 - (list.n/range +0 (dec sxs))))) + (list.n/range 0 (dec sxs))))) )) (structure: #export Monoid<Array> (All [a] (Monoid (Array a))) - (def: identity (new +0)) + (def: identity (new 0)) (def: (compose xs ys) (let [sxs (size xs) sxy (size ys)] (|> (new (n/+ sxy sxs)) - (copy sxs +0 xs +0) - (copy sxy +0 ys sxs))))) + (copy sxs 0 xs 0) + (copy sxy 0 ys sxs))))) (structure: #export _ (Functor Array) (def: (map f ma) (let [arr-size (size ma)] - (if (n/= +0 arr-size) + (if (n/= 0 arr-size) (new arr-size) (list/fold (function (_ idx mb) (case (read idx ma) @@ -196,14 +196,14 @@ (#.Some x) (write idx (f x) mb))) (new arr-size) - (list.n/range +0 (dec arr-size))) + (list.n/range 0 (dec arr-size))) )))) (structure: #export _ (Fold Array) (def: (fold f init xs) (let [arr-size (size xs)] (loop [so-far init - idx +0] + idx 0] (if (n/< arr-size idx) (case (read idx xs) #.None @@ -218,7 +218,7 @@ (All [a] (-> (Predicate a) (Array a) Bit)) (let [size (..size array)] - (loop [idx +0] + (loop [idx 0] (if (n/< size idx) (case (..read idx array) (#.Some value) diff --git a/stdlib/source/lux/data/collection/bits.lux b/stdlib/source/lux/data/collection/bits.lux index 988a5b1dc..66cb2dab7 100644 --- a/stdlib/source/lux/data/collection/bits.lux +++ b/stdlib/source/lux/data/collection/bits.lux @@ -19,17 +19,17 @@ (type: #export Bits (Array Chunk)) -(def: empty-chunk Chunk (.i64 +0)) +(def: empty-chunk Chunk (.i64 0)) (def: #export empty Bits - (array.new +0)) + (array.new 0)) (def: #export (size bits) (-> Bits Nat) (array/fold (function (_ chunk total) (|> chunk i64.count (n/+ total))) - +0 + 0 bits)) (def: #export (capacity bits) @@ -38,7 +38,7 @@ (def: #export empty? (-> Bits Bit) - (|>> size (n/= +0))) + (|>> size (n/= 0))) (def: #export (get index bits) (-> Nat Bits Bit) @@ -62,7 +62,7 @@ (array.size input)) output ..empty] (let [idx|output (dec size|output)] - (if (n/> +0 size|output) + (if (n/> 0 size|output) (case (|> (..chunk idx|output input) (cond> [(new> (n/= chunk-index idx|output))] [(<op> bit-index)] @@ -70,7 +70,7 @@ ## else []) .nat) - +0 + 0 ## TODO: Remove 'no-op' once new-luxc is the official compiler. (let [no-op (recur (dec size|output) output)] no-op) @@ -92,7 +92,7 @@ (-> Bits Bits Bit) (let [chunks (n/min (array.size reference) (array.size sample))] - (loop [idx +0] + (loop [idx 0] (if (n/< chunks idx) (.or (|> (..chunk idx sample) (i64.and (..chunk idx reference)) @@ -104,7 +104,7 @@ (def: #export (not input) (-> Bits Bits) (case (array.size input) - +0 + 0 ..empty size|output @@ -112,11 +112,11 @@ output ..empty] (let [idx (dec size|output)] (case (|> input (..chunk idx) i64.not .nat) - +0 + 0 (recur (dec size|output) output) chunk - (if (n/> +0 size|output) + (if (n/> 0 size|output) (|> (if (is? ..empty output) (: Bits (array.new size|output)) output) @@ -129,18 +129,18 @@ (-> Bits Bits Bits) (case (n/max (array.size param) (array.size subject)) - +0 + 0 ..empty size|output (loop [size|output size|output output ..empty] (let [idx (dec size|output)] - (if (n/> +0 size|output) + (if (n/> 0 size|output) (case (|> (..chunk idx subject) (<op> (..chunk idx param)) .nat) - +0 + 0 (recur (dec size|output) output) chunk @@ -160,7 +160,7 @@ (def: (= reference sample) (let [size (n/max (array.size reference) (array.size sample))] - (loop [idx +0] + (loop [idx 0] (if (n/< size idx) (.and ("lux i64 =" (..chunk idx reference) diff --git a/stdlib/source/lux/data/collection/dictionary.lux b/stdlib/source/lux/data/collection/dictionary.lux index 49465c123..3d4e84207 100644 --- a/stdlib/source/lux/data/collection/dictionary.lux +++ b/stdlib/source/lux/data/collection/dictionary.lux @@ -75,7 +75,7 @@ ## Which is 32 zeroes, since the branching factor is 32. (def: clean-bitmap BitMap - +0) + 0) ## Bitmap position (while looking inside #Base nodes) is determined by ## getting 5 bits from a hash of the key being looked up and using @@ -88,35 +88,35 @@ ## shift in the shallowest node on the tree, which is the root node). (def: root-level Level - +0) + 0) ## The exponent to which 2 must be elevated, to reach the branching ## factor of the data-structure. (def: branching-exponent Nat - +5) + 5) ## The threshold on which #Hierarchy nodes are demoted to #Base nodes, ## which is 1/4 of the branching factor (or a left-shift 2). (def: demotion-threshold Nat - (i64.left-shift (n/- +2 branching-exponent) +1)) + (i64.left-shift (n/- 2 branching-exponent) 1)) ## The threshold on which #Base nodes are promoted to #Hierarchy nodes, ## which is 1/2 of the branching factor (or a left-shift 1). (def: promotion-threshold Nat - (i64.left-shift (n/- +1 branching-exponent) +1)) + (i64.left-shift (n/- 1 branching-exponent) 1)) ## The size of hierarchy-nodes, which is 2^(branching-exponent). (def: hierarchy-nodes-size Nat - (i64.left-shift branching-exponent +1)) + (i64.left-shift branching-exponent 1)) ## The cannonical empty node, which is just an empty #Base node. (def: empty Node - (#Base clean-bitmap (array.new +0))) + (#Base clean-bitmap (array.new 0))) ## Expands a copy of the array, to have 1 extra slot, which is used ## for storing the value. @@ -124,7 +124,7 @@ (All [a] (-> Index a (Array a) (Array a))) (let [old-size (array.size old-array)] (|> (array.new (inc old-size)) - (array.copy idx +0 old-array +0) + (array.copy idx 0 old-array 0) (array.write idx value) (array.copy (n/- idx old-size) idx old-array (inc idx))))) @@ -143,13 +143,13 @@ (All [a] (-> Index (Array a) (Array a))) (let [new-size (dec (array.size array))] (|> (array.new new-size) - (array.copy idx +0 array +0) + (array.copy idx 0 array 0) (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)) - (|>> 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. @@ -169,7 +169,7 @@ ## A mechanism to go from indices to bit-positions. (def: (->bit-position index) (-> Index BitPosition) - (i64.left-shift index +1)) + (i64.left-shift index 1)) ## The bit-position within a base that a given hash-code would have. (def: (bit-position level hash) @@ -234,8 +234,8 @@ [(set-bit-position (->bit-position idx) bitmap) (array.write insertion-idx (#.Left sub-node) base)]]) ))) - [+0 [clean-bitmap - (array.new (dec h-size))]] + [0 [clean-bitmap + (array.new (dec h-size))]] (list.indices (array.size h-array))))) ## When #Base nodes grow too large, they're promoted to #Hierarchy to @@ -264,7 +264,7 @@ #.None (undefined))] default)) - [+0 + [0 (array.new hierarchy-nodes-size)] hierarchy-indices))) @@ -326,9 +326,9 @@ ## the same, a new ## #Collisions node ## is added. - (#Collisions hash (|> (array.new +2) - (array.write +0 [key' val']) - (array.write +1 [key val]))) + (#Collisions hash (|> (array.new 2) + (array.write 0 [key' val']) + (array.write 1 [key val]))) ## Otherwise, I can ## just keep using ## #Base nodes, so I @@ -371,8 +371,8 @@ ## If the hashes are not equal, I create a new #Base node that ## contains the old #Collisions node, plus the new KV-pair. (|> (#Base (bit-position level _hash) - (|> (array.new +1) - (array.write +0 (#.Left node)))) + (|> (array.new 1) + (array.write 0 (#.Left node)))) (put' level hash key val Hash<k>))) )) @@ -460,7 +460,7 @@ ## But if so, then check the size of the collisions list. (#.Some idx) - (if (n/= +1 (array.size _colls)) + (if (n/= 1 (array.size _colls)) ## If there's only one left, then removing it leaves us with ## an empty node. empty @@ -505,14 +505,14 @@ (All [k v] (-> (Node k v) Nat)) (case node (#Hierarchy _size hierarchy) - (array/fold n/+ +0 (array/map size' hierarchy)) + (array/fold n/+ 0 (array/map size' hierarchy)) (#Base _ base) - (array/fold n/+ +0 (array/map (function (_ sub-node') - (case sub-node' - (#.Left sub-node) (size' sub-node) - (#.Right _) +1)) - base)) + (array/fold n/+ 0 (array/map (function (_ sub-node') + (case sub-node' + (#.Left sub-node) (size' sub-node) + (#.Right _) 1)) + base)) (#Collisions hash colls) (array.size colls) @@ -605,7 +605,7 @@ (def: #export empty? (All [k v] (-> (Dictionary k v) Bit)) - (|>> size (n/= +0))) + (|>> size (n/= 0))) (def: #export (entries dict) (All [k v] (-> (Dictionary k v) (List [k v]))) diff --git a/stdlib/source/lux/data/collection/dictionary/ordered.lux b/stdlib/source/lux/data/collection/dictionary/ordered.lux index 9e9a2ea8d..25c50367b 100644 --- a/stdlib/source/lux/data/collection/dictionary/ordered.lux +++ b/stdlib/source/lux/data/collection/dictionary/ordered.lux @@ -115,7 +115,7 @@ (loop [node (get@ #root dict)] (case node #.None - +0 + 0 (#.Some node) (inc (<op> (recur (get@ #left node)) diff --git a/stdlib/source/lux/data/collection/list.lux b/stdlib/source/lux/data/collection/list.lux index 2d74aad79..bbc649fb9 100644 --- a/stdlib/source/lux/data/collection/list.lux +++ b/stdlib/source/lux/data/collection/list.lux @@ -68,7 +68,7 @@ [(def: #export (<name> n xs) (All [a] (-> Nat (List a) (List a))) - (if (n/> +0 n) + (if (n/> 0 n) (case xs #.Nil #.Nil @@ -101,7 +101,7 @@ (def: #export (split n xs) (All [a] (-> Nat (List a) [(List a) (List a)])) - (if (n/> +0 n) + (if (n/> 0 n) (case xs #.Nil [#.Nil #.Nil] @@ -145,7 +145,7 @@ {#.doc "A list of the value x, repeated n times."} (All [a] (-> Nat a (List a))) - (if (n/> +0 n) + (if (n/> 0 n) (#.Cons [x (repeat (dec n) x)]) #.Nil)) @@ -229,7 +229,7 @@ (def: #export (size list) (All [a] (-> (List a) Nat)) - (fold (function (_ _ acc) (n/+ +1 acc)) +0 list)) + (fold (function (_ _ acc) (n/+ 1 acc)) 0 list)) (do-template [<name> <init> <op>] [(def: #export (<name> p xs) @@ -261,7 +261,7 @@ #.None (#.Cons [x xs']) - (if (n/= +0 i) + (if (n/= 0 i) (#.Some x) (nth (dec i) xs')))) @@ -382,40 +382,40 @@ ## [Syntax] (def: (identifier$ name) (-> Text Code) - [["" +0 +0] (#.Identifier "" name)]) + [["" 0 0] (#.Identifier "" name)]) (def: (nat/encode value) (-> Nat Text) (loop [input value output ""] - (let [digit (case (n/% +10 input) - +0 "0" - +1 "1" - +2 "2" - +3 "3" - +4 "4" - +5 "5" - +6 "6" - +7 "7" - +8 "8" - +9 "9" + (let [digit (case (n/% 10 input) + 0 "0" + 1 "1" + 2 "2" + 3 "3" + 4 "4" + 5 "5" + 6 "6" + 7 "7" + 8 "8" + 9 "9" _ (undefined)) output' ("lux text concat" digit output) - input' (n// +10 input)] - (if (n/= +0 input') - ("lux text concat" "+" output') + input' (n// 10 input)] + (if (n/= 0 input') + output' (recur input' output'))))) (macro: #export (zip tokens state) {#.doc (doc "Create list zippers with the specified number of input lists." - (def: #export zip2 (zip +2)) - (def: #export zip3 (zip +3)) - ((zip +3) xs ys zs))} + (def: #export zip2 (zip 2)) + (def: #export zip3 (zip 3)) + ((zip 3) xs ys zs))} (case tokens (^ (list [_ (#.Nat num-lists)])) - (if (n/> +0 num-lists) + (if (n/> 0 num-lists) (let [(^open ".") Functor<List> - indices (n/range +0 (dec num-lists)) + indices (n/range 0 (dec num-lists)) type-vars (: (List Code) (map (|>> nat/encode identifier$) indices)) zip-type (` (All [(~+ type-vars)] (-> (~+ (map (: (-> Code Code) (function (_ var) (` (List (~ var))))) @@ -447,19 +447,19 @@ _ (#.Left "Wrong syntax for zip"))) -(def: #export zip2 (zip +2)) -(def: #export zip3 (zip +3)) +(def: #export zip2 (zip 2)) +(def: #export zip3 (zip 3)) (macro: #export (zip-with tokens state) {#.doc (doc "Create list zippers with the specified number of input lists." - (def: #export zip2-with (zip-with +2)) - (def: #export zip3-with (zip-with +3)) - ((zip-with +2) i/+ xs ys))} + (def: #export zip2-with (zip-with 2)) + (def: #export zip3-with (zip-with 3)) + ((zip-with 2) i/+ xs ys))} (case tokens (^ (list [_ (#.Nat num-lists)])) - (if (n/> +0 num-lists) + (if (n/> 0 num-lists) (let [(^open ".") Functor<List> - indices (n/range +0 (dec num-lists)) + indices (n/range 0 (dec num-lists)) g!return-type (identifier$ "\treturn-type\t") g!func (identifier$ "\tfunc\t") type-vars (: (List Code) (map (|>> nat/encode identifier$) indices)) @@ -494,8 +494,8 @@ _ (#.Left "Wrong syntax for zip-with"))) -(def: #export zip2-with (zip-with +2)) -(def: #export zip3-with (zip-with +3)) +(def: #export zip2-with (zip-with 2)) +(def: #export zip3-with (zip-with 3)) (def: #export (last xs) (All [a] (-> (List a) (Maybe a))) @@ -545,7 +545,7 @@ (do Monad<M> [lMla MlMla ## TODO: Remove this version ASAP and use one below. - lla (: (($ +0) (List (List ($ +1)))) + lla (: (($ 0) (List (List ($ 1)))) (monad.seq @ lMla)) ## lla (monad.seq @ lMla) ] @@ -567,11 +567,11 @@ (def: #export (enumerate xs) {#.doc "Pairs every element in the list with its index, starting at 0."} (All [a] (-> (List a) (List [Nat a]))) - (enumerate' +0 xs)) + (enumerate' 0 xs)) (def: #export (indices size) {#.doc "Produces all the valid indices for a given size."} (All [a] (-> Nat (List Nat))) - (if (n/= +0 size) + (if (n/= 0 size) (list) - (|> size dec (n/range +0)))) + (|> size dec (n/range 0)))) diff --git a/stdlib/source/lux/data/collection/queue/priority.lux b/stdlib/source/lux/data/collection/queue/priority.lux index ee1e5c1ca..1af9acaab 100644 --- a/stdlib/source/lux/data/collection/queue/priority.lux +++ b/stdlib/source/lux/data/collection/queue/priority.lux @@ -32,13 +32,13 @@ (All [a] (-> (Queue a) Nat)) (case queue #.None - +0 + 0 (#.Some fingers) (loop [node (get@ #finger.node fingers)] (case node (#finger.Leaf _ _) - +1 + 1 (#finger.Branch _ left right) (n/+ (recur left) (recur right)))))) diff --git a/stdlib/source/lux/data/collection/row.lux b/stdlib/source/lux/data/collection/row.lux index 1a12e3d9f..3951aadd1 100644 --- a/stdlib/source/lux/data/collection/row.lux +++ b/stdlib/source/lux/data/collection/row.lux @@ -35,11 +35,11 @@ (def: branching-exponent Nat - +5) + 5) (def: root-level Level - +0) + 0) (do-template [<name> <op>] [(def: <name> @@ -52,7 +52,7 @@ (def: full-node-size Nat - (i64.left-shift branching-exponent +1)) + (i64.left-shift branching-exponent 1)) (def: branch-idx-mask Nat @@ -69,23 +69,23 @@ (def: (tail-off vec-size) (-> Nat Nat) (if (n/< full-node-size vec-size) - +0 + 0 (|> (dec vec-size) (i64.logical-right-shift branching-exponent) (i64.left-shift branching-exponent)))) (def: (new-path level tail) (All [a] (-> Level (Base a) (Node a))) - (if (n/= +0 level) + (if (n/= 0 level) (#Base tail) (|> (new-hierarchy []) - (array.write +0 (new-path (level-down level) tail)) + (array.write 0 (new-path (level-down level) tail)) #Hierarchy))) (def: (new-tail singleton) (All [a] (-> a (Base a))) - (|> (array.new +1) - (array.write +0 singleton))) + (|> (array.new 1) + (array.write 0 singleton))) (def: (push-tail size level tail parent) (All [a] (-> Nat Level (Base a) (Hierarchy a) (Hierarchy a))) @@ -113,7 +113,7 @@ (All [a] (-> a (Base a) (Base a))) (let [tail-size (array.size tail)] (|> (array.new (inc tail-size)) - (array.copy tail-size +0 tail +0) + (array.copy tail-size 0 tail 0) (array.write tail-size val)))) (def: (put' level idx val hierarchy) @@ -125,7 +125,7 @@ (array.write sub-idx (#Hierarchy (put' (level-down level) idx val sub-node)))) (^multi (#.Some (#Base base)) - (n/= +0 (level-down level))) + (n/= 0 (level-down level))) (|> (array.clone hierarchy) (array.write sub-idx (|> (array.clone base) (array.write (branch-idx idx) val) @@ -136,8 +136,8 @@ (def: (pop-tail size level hierarchy) (All [a] (-> Nat Level (Hierarchy a) (Maybe (Hierarchy a)))) - (let [sub-idx (branch-idx (i64.logical-right-shift level (n/- +2 size)))] - (cond (n/= +0 sub-idx) + (let [sub-idx (branch-idx (i64.logical-right-shift level (n/- 2 size)))] + (cond (n/= 0 sub-idx) #.None (n/> branching-exponent level) @@ -183,9 +183,9 @@ (def: #export empty Row {#level (level-up root-level) - #size +0 + #size 0 #root (array.new full-node-size) - #tail (array.new +0)}) + #tail (array.new 0)}) (def: #export (size row) (All [a] (-> (Row a) Nat)) @@ -203,17 +203,17 @@ ## Otherwise, push tail into the tree ## -------------------------------------------------------- ## Will the root experience an overflow with this addition? - (|> (if (n/> (i64.left-shift (get@ #level vec) +1) + (|> (if (n/> (i64.left-shift (get@ #level vec) 1) (i64.logical-right-shift branching-exponent vec-size)) ## If so, a brand-new root must be established, that is ## 1-level taller. (|> vec - (set@ #root (|> (: (Hierarchy ($ +0)) + (set@ #root (|> (: (Hierarchy ($ 0)) (new-hierarchy [])) ## TODO: Remove version above once new-luxc becomes the standard compiler. ## (new-hierarchy []) - (array.write +0 (#Hierarchy (get@ #root vec))) - (array.write +1 (new-path (get@ #level vec) (get@ #tail vec))))) + (array.write 0 (#Hierarchy (get@ #root vec))) + (array.write 1 (new-path (get@ #level vec) (get@ #tail vec))))) (update@ #level level-up)) ## Otherwise, just push the current tail onto the root. (|> vec @@ -227,7 +227,7 @@ (def: (base-for idx vec) (All [a] (-> Index (Row a) (Maybe (Base a)))) (let [vec-size (get@ #size vec)] - (if (and (n/>= +0 idx) + (if (and (n/>= 0 idx) (n/< vec-size idx)) (if (n/>= (tail-off vec-size) idx) (#.Some (get@ #tail vec)) @@ -257,13 +257,13 @@ (def: #export (put idx val vec) (All [a] (-> Nat a (Row a) (Row a))) (let [vec-size (get@ #size vec)] - (if (and (n/>= +0 idx) + (if (and (n/>= 0 idx) (n/< vec-size idx)) (if (n/>= (tail-off vec-size) idx) (|> vec ## (update@ #tail (|>> array.clone (array.write (branch-idx idx) val))) ## TODO: Remove once new-luxc becomes the standard compiler. - (update@ #tail (: (-> (Base ($ +0)) (Base ($ +0))) + (update@ #tail (: (-> (Base ($ 0)) (Base ($ 0))) (|>> array.clone (array.write (branch-idx idx) val)))) ) (|> vec @@ -282,29 +282,29 @@ (def: #export (pop vec) (All [a] (-> (Row a) (Row a))) (case (get@ #size vec) - +0 + 0 empty - +1 + 1 empty vec-size - (if (|> vec-size (n/- (tail-off vec-size)) (n/> +1)) + (if (|> vec-size (n/- (tail-off vec-size)) (n/> 1)) (let [old-tail (get@ #tail vec) new-tail-size (dec (array.size old-tail))] (|> vec (update@ #size dec) (set@ #tail (|> (array.new new-tail-size) - (array.copy new-tail-size +0 old-tail +0))))) + (array.copy new-tail-size 0 old-tail 0))))) (maybe.assume (do maybe.Monad<Maybe> - [new-tail (base-for (n/- +2 vec-size) vec) + [new-tail (base-for (n/- 2 vec-size) vec) #let [[level' root'] (let [init-level (get@ #level vec)] (loop [level init-level root (maybe.default (new-hierarchy []) (pop-tail vec-size init-level (get@ #root vec)))] (if (n/> branching-exponent level) - (case [(array.read +1 root) (array.read +0 root)] + (case [(array.read 1 root) (array.read 0 root)] [#.None (#.Some (#Hierarchy sub-node))] (recur (level-down level) sub-node) @@ -338,12 +338,12 @@ (def: #export empty? (All [a] (-> (Row a) Bit)) - (|>> (get@ #size) (n/= +0))) + (|>> (get@ #size) (n/= 0))) ## [Syntax] (syntax: #export (row {elems (p.some s.any)}) {#.doc (doc "Row literals." - (row 10 20 30 40))} + (row +10 +20 +30 +40))} (wrap (list (` (from-list (list (~+ elems))))))) ## [Structures] diff --git a/stdlib/source/lux/data/collection/sequence.lux b/stdlib/source/lux/data/collection/sequence.lux index 2f9cf3722..6529a1ced 100644 --- a/stdlib/source/lux/data/collection/sequence.lux +++ b/stdlib/source/lux/data/collection/sequence.lux @@ -62,7 +62,7 @@ (def: #export (nth idx s) (All [a] (-> Nat (Sequence a) a)) (let [[h t] (continuation.run s)] - (if (n/> +0 idx) + (if (n/> 0 idx) (nth (dec idx) t) h))) @@ -93,7 +93,7 @@ [(list) xs])))] [take-while drop-while split-while (-> a Bit) (pred x) pred] - [take drop split Nat (n/> +0 pred) (dec pred)] + [take drop split Nat (n/> 0 pred) (dec pred)] ) (def: #export (unfold step init) @@ -138,7 +138,7 @@ {branches (p.some s.any)}) {#.doc (doc "Allows destructuring of sequences in pattern-matching expressions." "Caveat emptor: Only use it for destructuring, and not for testing values within the sequences." - (let [(^sequence& x y z _tail) (some-sequence-func 1 2 3)] + (let [(^sequence& x y z _tail) (some-sequence-func +1 +2 +3)] (func x y z)))} (with-gensyms [g!sequence] (let [body+ (` (let [(~+ (list/join (list/map (function (_ pattern) diff --git a/stdlib/source/lux/data/collection/set.lux b/stdlib/source/lux/data/collection/set.lux index ef39c98e0..6de27eb24 100644 --- a/stdlib/source/lux/data/collection/set.lux +++ b/stdlib/source/lux/data/collection/set.lux @@ -65,13 +65,13 @@ (def: (hash set) (let [[Hash<a> _] (:representation set)] (list/fold (function (_ elem acc) (n/+ (:: Hash<a> hash elem) acc)) - +0 + 0 (..to-list set))))) ) (def: #export empty? (All [a] (-> (Set a) Bit)) - (|>> ..size (n/= +0))) + (|>> ..size (n/= 0))) (def: #export (from-list Hash<a> xs) (All [a] (-> (Hash a) (List a) (Set a))) diff --git a/stdlib/source/lux/data/collection/set/multi.lux b/stdlib/source/lux/data/collection/set/multi.lux index eb8e914e3..d152c8506 100644 --- a/stdlib/source/lux/data/collection/set/multi.lux +++ b/stdlib/source/lux/data/collection/set/multi.lux @@ -25,15 +25,15 @@ (def: #export size (All [a] (-> (Set a) Nat)) - (|>> :representation dictionary.values (list/fold n/+ +0))) + (|>> :representation dictionary.values (list/fold n/+ 0))) (def: #export (add/* count elem set) (All [a] (-> Nat a (Set a) (Set a))) - (|> set :representation (dictionary.update~ elem +0 (n/+ count)) :abstraction)) + (|> set :representation (dictionary.update~ elem 0 (n/+ count)) :abstraction)) (def: #export add/1 (All [a] (-> a (Set a) (Set a))) - (add/* +1)) + (add/* 1)) (def: #export (remove/* count elem set) (All [a] (-> Nat a (Set a) (Set a))) @@ -53,18 +53,18 @@ (def: #export remove/1 (All [a] (-> a (Set a) (Set a))) - (remove/* +1)) + (remove/* 1)) (def: #export (multiplicity elem set) (All [a] (-> a (Set a) Nat)) - (|> set :representation (dictionary.get elem) (maybe.default +0))) + (|> set :representation (dictionary.get elem) (maybe.default 0))) (def: #export to-list (All [a] (-> (Set a) (List a))) (let [append (: (All [a] (-> a Nat (List a) (List a))) (function (append elem count output) (case count - +0 output + 0 output _ (|> output (#.Cons elem) (append elem (dec count))))))] (|>> :representation dictionary.entries @@ -105,7 +105,7 @@ (|> reference :representation (dictionary.get elem) - (maybe.default +0) + (maybe.default 0) (n/>= count)))))) (def: #export (support set) @@ -124,7 +124,7 @@ (list.every? (function (_ [elem count]) (|> sample (dictionary.get elem) - (maybe.default +0) + (maybe.default 0) (n/= count)))))))) (structure: #export Hash<Set> (All [a] (Hash (Set a))) @@ -134,17 +134,17 @@ (let [[Hash<a> _] set] (list/fold (function (_ [elem count] acc) (|> elem (:: Hash<a> hash) (n/* count) (n/+ acc))) - +0 + 0 (dictionary.entries set))))) ) (def: #export (member? set elem) (All [a] (-> (Set a) a Bit)) - (|> set (..multiplicity elem) (n/> +0))) + (|> set (..multiplicity elem) (n/> 0))) (def: #export empty? (All [a] (-> (Set a) Bit)) - (|>> ..size (n/= +0))) + (|>> ..size (n/= 0))) (def: #export (from-list Hash<a> subject) (All [a] (-> (Hash a) (List a) (Set a))) diff --git a/stdlib/source/lux/data/collection/tree/rose.lux b/stdlib/source/lux/data/collection/tree/rose.lux index 62b65422a..fc25f414f 100644 --- a/stdlib/source/lux/data/collection/tree/rose.lux +++ b/stdlib/source/lux/data/collection/tree/rose.lux @@ -49,9 +49,9 @@ (syntax: #export (tree {root tree^}) {#.doc (doc "Tree literals." - (tree Int [10 {20 {} - 30 {} - 40 {}}]))} + (tree Int [+10 {+20 {} + +30 {} + +40 {}}]))} (wrap (list (` (~ (loop [[value children] root] (` {#value (~ value) #children (list (~+ (list/map recur children)))}))))))) diff --git a/stdlib/source/lux/data/collection/tree/rose/zipper.lux b/stdlib/source/lux/data/collection/tree/rose/zipper.lux index 4181bd406..f9380577b 100644 --- a/stdlib/source/lux/data/collection/tree/rose/zipper.lux +++ b/stdlib/source/lux/data/collection/tree/rose/zipper.lux @@ -86,7 +86,7 @@ (#.Some parent) (|> parent ## TODO: Remove once new-luxc becomes the standard compiler. - (update@ #node (: (-> (Tree ($ +0)) (Tree ($ +0))) + (update@ #node (: (-> (Tree ($ 0)) (Tree ($ 0))) (function (_ node) (set@ #//.children (list/compose (list.reverse (get@ #lefts zipper)) (#.Cons (get@ #node zipper) @@ -155,7 +155,7 @@ (update@ [#node #//.children] (function (_ children) ## TODO: Remove once new-luxc becomes the standard compiler. - (list& (: (Tree ($ +0)) + (list& (: (Tree ($ 0)) (//.tree [value {}])) children) ## (list& (//.tree [value {}]) @@ -169,7 +169,7 @@ (function (_ children) (list/compose children ## TODO: Remove once new-luxc becomes the standard compiler. - (list (: (Tree ($ +0)) + (list (: (Tree ($ 0)) (//.tree [value {}]))) ## (list (//.tree [value {}])) )) @@ -203,7 +203,7 @@ (#.Some (|> zipper (update@ <side> (function (_ side) ## TODO: Remove once new-luxc becomes the standard compiler. - (#.Cons (: (Tree ($ +0)) + (#.Cons (: (Tree ($ 0)) (//.tree [value {}])) side) ## (#.Cons (//.tree [value {}]) diff --git a/stdlib/source/lux/data/color.lux b/stdlib/source/lux/data/color.lux index 8ff70f96c..e070ced40 100644 --- a/stdlib/source/lux/data/color.lux +++ b/stdlib/source/lux/data/color.lux @@ -8,7 +8,7 @@ [type abstract]]) -(def: rgb Nat +256) +(def: rgb Nat 256) (def: top Nat (dec rgb)) (def: rgb-factor Frac (|> top .int int-to-frac)) @@ -53,62 +53,62 @@ blue (scale-down blue) max ($_ f/max red green blue) min ($_ f/min red green blue) - luminance (|> (f/+ max min) (f// 2.0))] + luminance (|> (f/+ max min) (f// +2.0))] (if (f/= max min) ## Achromatic - [0.0 0.0 luminance] + [+0.0 +0.0 luminance] ## Chromatic (let [diff (|> max (f/- min)) saturation (|> diff - (f// (if (f/> 0.5 luminance) - (|> 2.0 (f/- max) (f/- min)) + (f// (if (f/> +0.5 luminance) + (|> +2.0 (f/- max) (f/- min)) (|> max (f/+ min))))) hue' (cond (f/= red max) (|> green (f/- blue) (f// diff) - (f/+ (if (f/< blue green) 6.0 0.0))) + (f/+ (if (f/< blue green) +6.0 +0.0))) (f/= green max) (|> blue (f/- red) (f// diff) - (f/+ 2.0)) + (f/+ +2.0)) ## (f/= blue max) (|> red (f/- green) (f// diff) - (f/+ 4.0)))] - [(|> hue' (f// 6.0)) + (f/+ +4.0)))] + [(|> hue' (f// +6.0)) saturation luminance])))) (def: (hue-to-rgb p q t) (-> Frac Frac Frac Frac) - (let [t (cond (f/< 0.0 t) (f/+ 1.0 t) - (f/> 1.0 t) (f/- 1.0 t) + (let [t (cond (f/< +0.0 t) (f/+ +1.0 t) + (f/> +1.0 t) (f/- +1.0 t) ## else t) - f2/3 (f// 3.0 2.0)] - (cond (f/< (f// 6.0 1.0) t) - (|> q (f/- p) (f/* 6.0) (f/* t) (f/+ p)) + f2/3 (f// +3.0 +2.0)] + (cond (f/< (f// +6.0 +1.0) t) + (|> q (f/- p) (f/* +6.0) (f/* t) (f/+ p)) - (f/< (f// 2.0 1.0) t) + (f/< (f// +2.0 +1.0) t) q (f/< f2/3 t) - (|> q (f/- p) (f/* (|> f2/3 (f/- t))) (f/* 6.0) (f/+ p)) + (|> q (f/- p) (f/* (|> f2/3 (f/- t))) (f/* +6.0) (f/+ p)) ## else p))) (def: #export (from-hsl [hue saturation luminance]) (-> [Frac Frac Frac] Color) - (if (f/= 0.0 saturation) + (if (f/= +0.0 saturation) ## Achromatic (let [intensity (scale-up luminance)] (color [intensity intensity intensity])) ## Chromatic - (let [q (if (f/< 0.5 luminance) - (|> saturation (f/+ 1.0) (f/* luminance)) + (let [q (if (f/< +0.5 luminance) + (|> saturation (f/+ +1.0) (f/* luminance)) (|> luminance (f/+ saturation) (f/- (f/* saturation luminance)))) - p (|> luminance (f/* 2.0) (f/- q)) - third (|> 1.0 (f// 3.0))] + p (|> luminance (f/* +2.0) (f/- q)) + third (|> +1.0 (f// +3.0))] (color [(scale-up (|> hue (f/+ third) (hue-to-rgb p q))) (scale-up (|> hue (hue-to-rgb p q))) (scale-up (|> hue (f/- third) (hue-to-rgb p q)))])))) @@ -123,41 +123,41 @@ min ($_ f/min red green blue) brightness max diff (|> max (f/- min)) - saturation (if (f/= 0.0 max) - 0.0 + saturation (if (f/= +0.0 max) + +0.0 (|> diff (f// max)))] (if (f/= max min) ## Achromatic - [0.0 saturation brightness] + [+0.0 saturation brightness] ## Chromatic (let [hue (cond (f/= red max) (|> green (f/- blue) (f// diff) - (f/+ (if (f/< blue green) 6.0 0.0))) + (f/+ (if (f/< blue green) +6.0 +0.0))) (f/= green max) (|> blue (f/- red) (f// diff) - (f/+ 2.0)) + (f/+ +2.0)) ## (f/= blue max) (|> red (f/- green) (f// diff) - (f/+ 4.0)))] - [(|> hue (f// 6.0)) + (f/+ +4.0)))] + [(|> hue (f// +6.0)) saturation brightness])))) (def: #export (from-hsb [hue saturation brightness]) (-> [Frac Frac Frac] Color) - (let [hue (|> hue (f/* 6.0)) + (let [hue (|> hue (f/* +6.0)) i (math.floor hue) f (|> hue (f/- i)) - p (|> 1.0 (f/- saturation) (f/* brightness)) - q (|> 1.0 (f/- (f/* f saturation)) (f/* brightness)) - t (|> 1.0 (f/- (|> 1.0 (f/- f) (f/* saturation))) (f/* brightness)) + p (|> +1.0 (f/- saturation) (f/* brightness)) + 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-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))] + 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))] (color [(scale-up red) (scale-up green) (scale-up blue)]))) @@ -168,34 +168,34 @@ red (scale-down red) green (scale-down green) blue (scale-down blue) - key (|> 1.0 (f/- ($_ f/max red green blue))) - f (if (f/< 1.0 key) - (|> 1.0 (f// (|> 1.0 (f/- key)))) - 0.0) - cyan (|> 1.0 (f/- red) (f/- key) (f/* f)) - magenta (|> 1.0 (f/- green) (f/- key) (f/* f)) - yellow (|> 1.0 (f/- blue) (f/- key) (f/* f))] + key (|> +1.0 (f/- ($_ f/max red green blue))) + f (if (f/< +1.0 key) + (|> +1.0 (f// (|> +1.0 (f/- key)))) + +0.0) + cyan (|> +1.0 (f/- red) (f/- key) (f/* f)) + magenta (|> +1.0 (f/- green) (f/- key) (f/* f)) + yellow (|> +1.0 (f/- blue) (f/- key) (f/* f))] [cyan magenta yellow key])) (def: #export (from-cmyk [cyan magenta yellow key]) (-> [Frac Frac Frac Frac] Color) - (if (f/= 1.0 key) - (color [+0 +0 +0]) - (let [red (|> (|> 1.0 (f/- cyan)) - (f/* (|> 1.0 (f/- key)))) - green (|> (|> 1.0 (f/- magenta)) - (f/* (|> 1.0 (f/- key)))) - blue (|> (|> 1.0 (f/- yellow)) - (f/* (|> 1.0 (f/- key))))] + (if (f/= +1.0 key) + (color [0 0 0]) + (let [red (|> (|> +1.0 (f/- cyan)) + (f/* (|> +1.0 (f/- key)))) + green (|> (|> +1.0 (f/- magenta)) + (f/* (|> +1.0 (f/- key)))) + blue (|> (|> +1.0 (f/- yellow)) + (f/* (|> +1.0 (f/- key))))] (color [(scale-up red) (scale-up green) (scale-up blue)])))) (def: (normalize ratio) (-> Frac Frac) - (cond (f/> 1.0 ratio) - (f/% 1.0 ratio) + (cond (f/> +1.0 ratio) + (f/% +1.0 ratio) - (f/< 0.0 ratio) - (|> 1.0 (f/+ (f/% 1.0 ratio))) + (f/< +0.0 ratio) + (|> +1.0 (f/+ (f/% +1.0 ratio))) ## else ratio)) @@ -203,7 +203,7 @@ (def: #export (interpolate ratio end start) (-> Frac Color Color Color) (let [dS (normalize ratio) - dE (|> 1.0 (f/- dS)) + dE (|> +1.0 (f/- dS)) interpolate' (: (-> Nat Nat Nat) (function (_ end start) (|> (|> start .int int-to-frac (f/* dS)) @@ -216,7 +216,7 @@ (interpolate' greenE greenS) (interpolate' blueE blueS)]))) -(def: black Color (color [+0 +0 +0])) +(def: black Color (color [0 0 0])) (def: white Color (color [top top top])) (do-template [<name> <target>] @@ -242,8 +242,8 @@ (let [[hue saturation luminance] (to-hsl color)] (from-hsl [hue (|> saturation - (f/* (|> 1.0 (<op> (normalize ratio)))) - (f/min 1.0)) + (f/* (|> +1.0 (<op> (normalize ratio)))) + (f/min +1.0)) luminance])))] [saturate f/+] @@ -253,7 +253,7 @@ (def: #export (gray-scale color) (-> Color Color) (let [[_ _ luminance] (to-hsl color)] - (from-hsl [0.0 0.0 luminance]))) + (from-hsl [+0.0 +0.0 luminance]))) (do-template [<name> <1> <2>] [(def: #export (<name> color) @@ -263,9 +263,9 @@ (from-hsl [(|> hue (f/+ <1>) normalize) saturation luminance]) (from-hsl [(|> hue (f/+ <2>) normalize) saturation luminance])]))] - [triad (|> 1.0 (f// 3.0)) (|> 2.0 (f// 3.0))] - [clash (|> 1.0 (f// 4.0)) (|> 3.0 (f// 4.0))] - [split-complement (|> 1.0 (f// 5.0)) (|> 3.0 (f// 5.0))] + [triad (|> +1.0 (f// +3.0)) (|> +2.0 (f// +3.0))] + [clash (|> +1.0 (f// +4.0)) (|> +3.0 (f// +4.0))] + [split-complement (|> +1.0 (f// +5.0)) (|> +3.0 (f// +5.0))] ) (do-template [<name> <1> <2> <3>] @@ -277,13 +277,13 @@ (from-hsl [(|> hue (f/+ <2>) normalize) saturation luminance]) (from-hsl [(|> hue (f/+ <3>) normalize) saturation luminance])]))] - [square (|> 1.0 (f// 4.0)) (|> 2.0 (f// 4.0)) (|> 3.0 (f// 4.0))] - [tetradic (|> 2.0 (f// 12.0)) (|> 6.0 (f// 12.0)) (|> 8.0 (f// 12.0))] + [square (|> +1.0 (f// +4.0)) (|> +2.0 (f// +4.0)) (|> +3.0 (f// +4.0))] + [tetradic (|> +2.0 (f// +12.0)) (|> +6.0 (f// +12.0)) (|> +8.0 (f// +12.0))] ) (def: #export (analogous results slice color) (-> Nat Frac Color (List Color)) - (if (n/= +0 results) + (if (n/= 0 results) (list) (let [[hue saturation luminance] (to-hsl color) slice (normalize slice)] @@ -291,15 +291,15 @@ (from-hsl [(|> idx .int int-to-frac (f/* slice) (f/+ hue) normalize) saturation luminance])) - (list.n/range +0 (dec results)))))) + (list.n/range 0 (dec results)))))) (def: #export (monochromatic results color) (-> Nat Color (List Color)) - (if (n/= +0 results) + (if (n/= 0 results) (list) (let [[hue saturation brightness] (to-hsb color) - slice (|> 1.0 (f// (|> results .int int-to-frac)))] - (|> (list.n/range +0 (dec results)) + slice (|> +1.0 (f// (|> results .int int-to-frac)))] + (|> (list.n/range 0 (dec results)) (list/map (|>> .int int-to-frac (f/* slice) (f/+ brightness) diff --git a/stdlib/source/lux/data/error.lux b/stdlib/source/lux/data/error.lux index 8054736e9..17d88a5a0 100644 --- a/stdlib/source/lux/data/error.lux +++ b/stdlib/source/lux/data/error.lux @@ -86,10 +86,10 @@ (macro: #export (default tokens compiler) {#.doc (doc "Allows you to provide a default value that will be used" "if a (Error x) value turns out to be #Error." - (is? 10 - (default 20 (#Success 10))) - (is? 20 - (default 20 (#Error "KABOOM!"))))} + (is? +10 + (default +20 (#Success +10))) + (is? +20 + (default +20 (#Error "KABOOM!"))))} (case tokens (^ (list else error)) (#Success [compiler (list (` (case (~ error) diff --git a/stdlib/source/lux/data/format/binary.lux b/stdlib/source/lux/data/format/binary.lux index b2feda2c5..4657b48d5 100644 --- a/stdlib/source/lux/data/format/binary.lux +++ b/stdlib/source/lux/data/format/binary.lux @@ -28,10 +28,10 @@ (type: #export Size Nat) -(def: #export size/8 +1) -(def: #export size/16 +2) -(def: #export size/32 +4) -(def: #export size/64 +8) +(def: #export size/8 1) +(def: #export size/16 2) +(def: #export size/32 4) +(def: #export size/64 8) (type: #export Read (p.Parser [Offset Binary])) @@ -46,7 +46,7 @@ ## Operators (def: #export (read format input) (All [a] (-> (Format a) Binary (Error a))) - (case ((get@ #read format) [+0 input]) + (case ((get@ #read format) [0 input]) (#error.Error msg) (#error.Error msg) @@ -59,7 +59,7 @@ (def: #export (write format value) (All [a] (-> (Format a) a Binary)) (let [[valueS valueT] ((get@ #write format) value)] - (|> valueS binary.create (valueT +0)))) + (|> valueS binary.create (valueT 0)))) ## Primitives (do-template [<name> <size> <read> <write>] @@ -91,9 +91,9 @@ {#read (do p.Monad<Parser> [flag (get@ #read bits/8)] (case flag - +0 (:: @ map (|>> #.Left) (get@ #read leftB)) - +1 (:: @ map (|>> #.Right) (get@ #read rightB)) - _ (p.lift (ex.throw invalid-tag [+2 (.nat flag)])))) + 0 (:: @ map (|>> #.Left) (get@ #read leftB)) + 1 (:: @ map (|>> #.Right) (get@ #read rightB)) + _ (p.lift (ex.throw invalid-tag [2 (.nat flag)])))) #write (function (_ altV) (case altV (#.Left leftV) @@ -101,7 +101,7 @@ [(.inc leftS) (function (_ offset binary) (|> binary - (binary.write/8 offset +0) + (binary.write/8 offset 0) error.assume (leftT (.inc offset))))]) @@ -110,7 +110,7 @@ [(.inc rightS) (function (_ offset binary) (|> binary - (binary.write/8 offset +1) + (binary.write/8 offset 1) error.assume (rightT (.inc offset))))]) ))}) @@ -141,7 +141,7 @@ {#read (function (_ input) (#error.Success [input default])) #write (function (_ value) - [+0 + [0 (function (_ offset binary) binary)])}) @@ -157,19 +157,19 @@ (case (: Nat data) (^template [<nat> <bit>] <nat> (#error.Success [(inc offset) binary] <bit>)) - ([+0 #0] - [+1 #1]) + ([0 #0] + [1 #1]) _ - (ex.throw invalid-tag [+2 data])) + (ex.throw invalid-tag [2 data])) (#error.Error error) (#error.Error error))) #write (function (_ value) - [+1 + [1 (function (_ offset binary) (|> binary - (binary.write/8 offset (if value +1 +0)) + (binary.write/8 offset (if value 1 0)) error.assume))])}) (def: #export nat (Format Nat) (:assume ..bits/64)) @@ -198,7 +198,7 @@ (error.assume (do error.Monad<Error> [_ (binary.write/64 offset size binary)] - (binary.copy size +0 value (n/+ size/64 offset) binary))))]))}) + (binary.copy size 0 value (n/+ size/64 offset) binary))))]))}) (def: #export text (Format Text) diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux index 02c05f5dd..549631f2a 100644 --- a/stdlib/source/lux/data/format/json.lux +++ b/stdlib/source/lux/data/format/json.lux @@ -55,7 +55,7 @@ (syntax: #export (json token) {#.doc (doc "A simple way to produce JSON literals." (json #1) - (json 123.456) + (json +123.456) (json "Some text") (json #null) (json ["this" "is" "an" "array"]) diff --git a/stdlib/source/lux/data/maybe.lux b/stdlib/source/lux/data/maybe.lux index d6b44e02d..57ff95727 100644 --- a/stdlib/source/lux/data/maybe.lux +++ b/stdlib/source/lux/data/maybe.lux @@ -84,9 +84,9 @@ (macro: #export (default tokens state) {#.doc "## Allows you to provide a default value that will be used ## if a (Maybe x) value turns out to be #.None. - (default 20 (#.Some 10)) => 10 + (default +20 (#.Some +10)) => +10 - (default 20 #.None) => 20"} + (default +20 #.None) => +20"} (case tokens (^ (list else maybe)) (let [g!temp (: Code [dummy-cursor (#.Identifier ["" ""])]) diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux index cb71b5b07..13ffe71da 100644 --- a/stdlib/source/lux/data/number.lux +++ b/stdlib/source/lux/data/number.lux @@ -10,7 +10,7 @@ interval [codec (#+ Codec)]] [data - ["e" error] + ["." error (#+ Error)] ["." maybe] ["." text]]] [/ @@ -51,8 +51,8 @@ (def: abs id) (def: (signum x) (case x - +0 +0 - _ +1)) + 0 0 + _ 1)) ) (do-template [<type> <order> <+> <-> <*> </> <%> <=> <<> <0> <1> <-1>] @@ -74,8 +74,8 @@ <1>)) )] - [ Int Order<Int> i/+ i/- i/* i// i/% i/= i/< 0 1 -1] - [Frac Order<Frac> f/+ f/- f/* f// f/% f/= f/< 0.0 1.0 -1.0] + [ Int Order<Int> i/+ i/- i/* i// i/% i/= i/< +0 +1 -1] + [Frac Order<Frac> f/+ f/- f/* f// f/% f/= f/< +0.0 +1.0 -1.0] ) (structure: #export _ (Number Rev) @@ -107,10 +107,10 @@ (def: top <top>) (def: bottom <bottom>))] - [ Nat Enum<Nat> (:coerce Nat -1) +0] - [ Int Enum<Int> 9_223_372_036_854_775_807 -9_223_372_036_854_775_808] + [ Nat Enum<Nat> (:coerce Nat -1) 0] + [ 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")] - [ Rev Enum<Rev> (:coerce Rev -1) (:coerce Rev +0)] + [ Rev Enum<Rev> (:coerce Rev -1) (:coerce Rev 0)] ) (do-template [<name> <type> <identity> <compose>] @@ -118,16 +118,16 @@ (def: identity <identity>) (def: compose <compose>))] - [ Add@Monoid<Nat> Nat +0 n/+] - [ Mul@Monoid<Nat> Nat +1 n/*] + [ Add@Monoid<Nat> Nat 0 n/+] + [ Mul@Monoid<Nat> Nat 1 n/*] [ Max@Monoid<Nat> Nat (:: Interval<Nat> bottom) n/max] [ Min@Monoid<Nat> Nat (:: Interval<Nat> top) n/min] - [ Add@Monoid<Int> Int 0 i/+] - [ Mul@Monoid<Int> Int 1 i/*] + [ Add@Monoid<Int> Int +0 i/+] + [ Mul@Monoid<Int> Int +1 i/*] [ Max@Monoid<Int> Int (:: Interval<Int> bottom) i/max] [ Min@Monoid<Int> Int (:: Interval<Int> top) i/min] - [Add@Monoid<Frac> Frac 0.0 f/+] - [Mul@Monoid<Frac> Frac 1.0 f/*] + [Add@Monoid<Frac> Frac +0.0 f/+] + [Mul@Monoid<Frac> Frac +1.0 f/*] [Max@Monoid<Frac> Frac (:: Interval<Frac> bottom) f/max] [Min@Monoid<Frac> Frac (:: Interval<Frac> top) f/min] [ Add@Monoid<Rev> Rev (:: Interval<Rev> bottom) r/+] @@ -140,10 +140,10 @@ [(def: #export <name> {#.doc <doc>} Frac - (f// 0.0 <numerator>))] + (f// +0.0 <numerator>))] - [not-a-number 0.0 "Not a number."] - [positive-infinity 1.0 "Positive infinity."] + [not-a-number +0.0 "Not a number."] + [positive-infinity +1.0 "Positive infinity."] [negative-infinity -1.0 "Negative infinity."] ) @@ -166,10 +166,10 @@ (def: (decode input) (case (<decoder> [input]) (#.Some value) - (#e.Success value) + (#error.Success value) #.None - (#e.Error <error>))))] + (#error.Error <error>))))] [Frac "lux frac encode" "lux frac decode" "Could not decode Frac"] ) @@ -182,113 +182,113 @@ (def: (binary-character value) (-> Nat (Maybe Text)) (case value - +0 (#.Some "0") - +1 (#.Some "1") + 0 (#.Some "0") + 1 (#.Some "1") _ #.None)) (def: (binary-value digit) (-> Text (Maybe Nat)) (case digit - "0" (#.Some +0) - "1" (#.Some +1) + "0" (#.Some 0) + "1" (#.Some 1) _ #.None)) (def: (octal-character value) (-> Nat (Maybe Text)) (case value - +0 (#.Some "0") - +1 (#.Some "1") - +2 (#.Some "2") - +3 (#.Some "3") - +4 (#.Some "4") - +5 (#.Some "5") - +6 (#.Some "6") - +7 (#.Some "7") + 0 (#.Some "0") + 1 (#.Some "1") + 2 (#.Some "2") + 3 (#.Some "3") + 4 (#.Some "4") + 5 (#.Some "5") + 6 (#.Some "6") + 7 (#.Some "7") _ #.None)) (def: (octal-value digit) (-> Text (Maybe Nat)) (case digit - "0" (#.Some +0) - "1" (#.Some +1) - "2" (#.Some +2) - "3" (#.Some +3) - "4" (#.Some +4) - "5" (#.Some +5) - "6" (#.Some +6) - "7" (#.Some +7) + "0" (#.Some 0) + "1" (#.Some 1) + "2" (#.Some 2) + "3" (#.Some 3) + "4" (#.Some 4) + "5" (#.Some 5) + "6" (#.Some 6) + "7" (#.Some 7) _ #.None)) (def: (decimal-character value) (-> Nat (Maybe Text)) (case value - +0 (#.Some "0") - +1 (#.Some "1") - +2 (#.Some "2") - +3 (#.Some "3") - +4 (#.Some "4") - +5 (#.Some "5") - +6 (#.Some "6") - +7 (#.Some "7") - +8 (#.Some "8") - +9 (#.Some "9") + 0 (#.Some "0") + 1 (#.Some "1") + 2 (#.Some "2") + 3 (#.Some "3") + 4 (#.Some "4") + 5 (#.Some "5") + 6 (#.Some "6") + 7 (#.Some "7") + 8 (#.Some "8") + 9 (#.Some "9") _ #.None)) (def: (decimal-value digit) (-> Text (Maybe Nat)) (case digit - "0" (#.Some +0) - "1" (#.Some +1) - "2" (#.Some +2) - "3" (#.Some +3) - "4" (#.Some +4) - "5" (#.Some +5) - "6" (#.Some +6) - "7" (#.Some +7) - "8" (#.Some +8) - "9" (#.Some +9) + "0" (#.Some 0) + "1" (#.Some 1) + "2" (#.Some 2) + "3" (#.Some 3) + "4" (#.Some 4) + "5" (#.Some 5) + "6" (#.Some 6) + "7" (#.Some 7) + "8" (#.Some 8) + "9" (#.Some 9) _ #.None)) (def: (hexadecimal-character value) (-> Nat (Maybe Text)) (case value - +0 (#.Some "0") - +1 (#.Some "1") - +2 (#.Some "2") - +3 (#.Some "3") - +4 (#.Some "4") - +5 (#.Some "5") - +6 (#.Some "6") - +7 (#.Some "7") - +8 (#.Some "8") - +9 (#.Some "9") - +10 (#.Some "A") - +11 (#.Some "B") - +12 (#.Some "C") - +13 (#.Some "D") - +14 (#.Some "E") - +15 (#.Some "F") + 0 (#.Some "0") + 1 (#.Some "1") + 2 (#.Some "2") + 3 (#.Some "3") + 4 (#.Some "4") + 5 (#.Some "5") + 6 (#.Some "6") + 7 (#.Some "7") + 8 (#.Some "8") + 9 (#.Some "9") + 10 (#.Some "A") + 11 (#.Some "B") + 12 (#.Some "C") + 13 (#.Some "D") + 14 (#.Some "E") + 15 (#.Some "F") _ #.None)) (def: (hexadecimal-value digit) (-> Text (Maybe Nat)) (case digit - "0" (#.Some +0) - "1" (#.Some +1) - "2" (#.Some +2) - "3" (#.Some +3) - "4" (#.Some +4) - "5" (#.Some +5) - "6" (#.Some +6) - "7" (#.Some +7) - "8" (#.Some +8) - "9" (#.Some +9) - (^or "a" "A") (#.Some +10) - (^or "b" "B") (#.Some +11) - (^or "c" "C") (#.Some +12) - (^or "d" "D") (#.Some +13) - (^or "e" "E") (#.Some +14) - (^or "f" "F") (#.Some +15) + "0" (#.Some 0) + "1" (#.Some 1) + "2" (#.Some 2) + "3" (#.Some 3) + "4" (#.Some 4) + "5" (#.Some 5) + "6" (#.Some 6) + "7" (#.Some 7) + "8" (#.Some 8) + "9" (#.Some 9) + (^or "a" "A") (#.Some 10) + (^or "b" "B") (#.Some 11) + (^or "c" "C") (#.Some 12) + (^or "d" "D") (#.Some 13) + (^or "e" "E") (#.Some 14) + (^or "f" "F") (#.Some 15) _ #.None)) (do-template [<struct> <base> <to-character> <to-value> <error>] @@ -299,98 +299,111 @@ (let [digit (maybe.assume (<to-character> (n/% <base> input))) output' ("lux text concat" digit output) input' (n// <base> input)] - (if (n/= +0 input') - ("lux text concat" "+" output') + (if (n/= 0 input') + output' (recur input' output'))))) (def: (decode repr) (let [input-size ("lux text size" repr)] - (if (n/>= +2 input-size) - (case ("lux text char" repr +0) - (^ (#.Some (char "+"))) - (loop [idx +1 - output +0] - (if (n/< input-size idx) - (let [digit (maybe.assume (get-char repr idx))] - (case (<to-value> digit) - #.None - (#e.Error ("lux text concat" <error> repr)) - - (#.Some digit-value) - (recur (inc idx) - (|> output (n/* <base>) (n/+ digit-value))))) - (#e.Success output))) + (if (n/> 0 input-size) + (loop [idx 0 + output 0] + (if (n/< input-size idx) + (let [digit (maybe.assume (get-char repr idx))] + (case (<to-value> digit) + #.None + (#error.Error ("lux text concat" <error> repr)) + + (#.Some digit-value) + (recur (inc idx) + (|> output (n/* <base>) (n/+ digit-value))))) + (#error.Success output))) + (#error.Error ("lux text concat" <error> repr))))))] + + [Binary@Codec<Text,Nat> 2 binary-character binary-value "Invalid binary syntax for Nat: "] + [Octal@Codec<Text,Nat> 8 octal-character octal-value "Invalid octal syntax for Nat: "] + [_ 10 decimal-character decimal-value "Invalid syntax for Nat: "] + [Hex@Codec<Text,Nat> 16 hexadecimal-character hexadecimal-value "Invalid hexadecimal syntax for Nat: "] + ) - _ - (#e.Error ("lux text concat" <error> repr))) - (#e.Error ("lux text concat" <error> repr))))))] +(def: (int/sign!! value) + (-> Int Text) + (if (i/< +0 value) + "-" + "+")) - [Binary@Codec<Text,Nat> +2 binary-character binary-value "Invalid binary syntax for Nat: "] - [Octal@Codec<Text,Nat> +8 octal-character octal-value "Invalid octal syntax for Nat: "] - [_ +10 decimal-character decimal-value "Invalid syntax for Nat: "] - [Hex@Codec<Text,Nat> +16 hexadecimal-character hexadecimal-value "Invalid hexadecimal syntax for Nat: "] - ) +(def: (int/sign?? representation) + (-> Text (Maybe Int)) + (case (get-char representation 0) + (^ (#.Some "-")) + (#.Some -1) + + (^ (#.Some "+")) + (#.Some +1) + + _ + #.None)) + +(def: (int-decode-loop input-size repr sign <base> <to-value> <error>) + (-> Nat Text Int Int (-> Text (Maybe Nat)) Text (Error Int)) + (loop [idx 1 + output +0] + (if (n/< input-size idx) + (let [digit (maybe.assume (get-char repr idx))] + (case (<to-value> digit) + #.None + (#error.Error <error>) + + (#.Some digit-value) + (recur (inc idx) + (|> output (i/* <base>) (i/+ (.int digit-value)))))) + (#error.Success (i/* sign output))))) (do-template [<struct> <base> <to-character> <to-value> <error>] [(structure: #export <struct> (Codec Text Int) (def: (encode value) - (if (i/= 0 value) - "0" - (let [sign (if (i/< 0 value) - "-" - "")] - (loop [input (|> value (i// <base>) (:: Number<Int> abs)) - 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> (.nat (i/% <base> input))))] - (recur (i// <base> input) - ("lux text concat" digit output)))))))) + (if (i/= +0 value) + "+0" + (loop [input (|> value (i// <base>) (:: Number<Int> abs)) + output (|> value (i/% <base>) (:: Number<Int> abs) .nat + <to-character> + maybe.assume)] + (if (i/= +0 input) + ("lux text concat" (int/sign!! value) output) + (let [digit (maybe.assume (<to-character> (.nat (i/% <base> input))))] + (recur (i// <base> input) + ("lux text concat" digit output))))))) (def: (decode repr) (let [input-size ("lux text size" repr)] - (if (n/>= +1 input-size) - (let [sign (case (get-char repr +0) - (^ (#.Some "-")) - -1 - - _ - 1)] - (loop [idx (if (i/= -1 sign) +1 +0) - output 0] - (if (n/< input-size idx) - (let [digit (maybe.assume (get-char repr idx))] - (case (<to-value> digit) - #.None - (#e.Error <error>) - - (#.Some digit-value) - (recur (inc idx) - (|> output (i/* <base>) (i/+ (:coerce Int digit-value)))))) - (#e.Success (i/* sign output))))) - (#e.Error <error>)))))] - - [Binary@Codec<Text,Int> 2 binary-character binary-value "Invalid binary syntax for Int: "] - [Octal@Codec<Text,Int> 8 octal-character octal-value "Invalid octal syntax for Int: "] - [_ 10 decimal-character decimal-value "Invalid syntax for Int: "] - [Hex@Codec<Text,Int> 16 hexadecimal-character hexadecimal-value "Invalid hexadecimal syntax for Int: "] + (if (n/> 1 input-size) + (case (int/sign?? repr) + (#.Some sign) + (int-decode-loop input-size repr sign <base> <to-value> <error>) + + #.None + (#error.Error <error>)) + (#error.Error <error>)))))] + + [Binary@Codec<Text,Int> +2 binary-character binary-value "Invalid binary syntax for Int: "] + [Octal@Codec<Text,Int> +8 octal-character octal-value "Invalid octal syntax for Int: "] + [_ +10 decimal-character decimal-value "Invalid syntax for Int: "] + [Hex@Codec<Text,Int> +16 hexadecimal-character hexadecimal-value "Invalid hexadecimal syntax for Int: "] ) (def: (de-prefix input) (-> Text Text) - (maybe.assume ("lux text clip" input +1 ("lux text size" input)))) + (maybe.assume ("lux text clip" input 1 ("lux text size" input)))) (do-template [<struct> <nat> <char-bit-size> <error>] [(structure: #export <struct> (Codec Text Rev) (def: (encode value) (let [raw-output (de-prefix (:: <nat> encode (:coerce Nat value))) - max-num-chars (n// <char-bit-size> +64) + max-num-chars (n// <char-bit-size> 64) raw-size ("lux text size" raw-output) zero-padding (loop [zeroes-left (n/- raw-size max-num-chars) output ""] - (if (n/= +0 zeroes-left) + (if (n/= 0 zeroes-left) output (recur (dec zeroes-left) ("lux text concat" "0" output)))) @@ -399,20 +412,20 @@ (def: (decode repr) (let [repr-size ("lux text size" repr)] - (if (n/>= +2 repr-size) - (case ("lux text char" repr +0) + (if (n/>= 2 repr-size) + (case ("lux text char" repr 0) (^multi (^ (#.Some (char "."))) - [(:: <nat> decode ("lux text concat" "+" (de-prefix repr))) - (#e.Success output)]) - (#e.Success (:coerce Rev output)) + [(:: <nat> decode (de-prefix repr)) + (#error.Success output)]) + (#error.Success (:coerce Rev output)) _ - (#e.Error ("lux text concat" <error> repr))) - (#e.Error ("lux text concat" <error> repr))))))] + (#error.Error ("lux text concat" <error> repr))) + (#error.Error ("lux text concat" <error> repr))))))] - [Binary@Codec<Text,Rev> Binary@Codec<Text,Nat> +1 "Invalid binary syntax: "] - [Octal@Codec<Text,Rev> Octal@Codec<Text,Nat> +3 "Invalid octal syntax: "] - [Hex@Codec<Text,Rev> Hex@Codec<Text,Nat> +4 "Invalid hexadecimal syntax: "] + [Binary@Codec<Text,Rev> Binary@Codec<Text,Nat> 1 "Invalid binary syntax: "] + [Octal@Codec<Text,Rev> Octal@Codec<Text,Nat> 3 "Invalid octal syntax: "] + [Hex@Codec<Text,Rev> Hex@Codec<Text,Nat> 4 "Invalid hexadecimal syntax: "] ) (do-template [<struct> <int> <base> <char-set> <error>] @@ -420,55 +433,55 @@ (def: (encode value) (let [whole (frac-to-int value) whole-part (:: <int> encode whole) - decimal (:: Number<Frac> abs (f/% 1.0 value)) - decimal-part (if (f/= 0.0 decimal) + decimal (:: Number<Frac> abs (f/% +1.0 value)) + decimal-part (if (f/= +0.0 decimal) ".0" (loop [dec-left decimal output ""] - (if (f/= 0.0 dec-left) + (if (f/= +0.0 dec-left) ("lux text concat" "." output) (let [shifted (f/* <base> dec-left) digit (|> shifted (f/% <base>) frac-to-int .nat (get-char <char-set>) maybe.assume)] - (recur (f/% 1.0 shifted) + (recur (f/% +1.0 shifted) ("lux text concat" output digit))))))] ("lux text concat" whole-part decimal-part))) (def: (decode repr) - (case ("lux text index" repr "." +0) + (case ("lux text index" repr "." 0) (#.Some split-index) - (let [whole-part (maybe.assume ("lux text clip" repr +0 split-index)) + (let [whole-part (maybe.assume ("lux text clip" repr 0 split-index)) 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)] - (i/>= 0 decimal)) - (let [sign (if (i/< 0 whole) + (^multi [(#error.Success whole) (#error.Success decimal)] + (i/>= +0 decimal)) + (let [sign (if (i/< +0 whole) -1.0 - 1.0) + +1.0) div-power (loop [muls-left ("lux text size" decimal-part) - output 1.0] - (if (n/= +0 muls-left) + output +1.0] + (if (n/= 0 muls-left) output (recur (dec muls-left) (f/* <base> output)))) adjusted-decimal (|> decimal int-to-frac (f// div-power)) dec-rev (case (:: Hex@Codec<Text,Rev> decode ("lux text concat" "." decimal-part)) - (#e.Success dec-rev) + (#error.Success dec-rev) dec-rev - (#e.Error error) + (#error.Error error) (error! error))] - (#e.Success (f/+ (int-to-frac whole) - (f/* sign adjusted-decimal)))) + (#error.Success (f/+ (int-to-frac whole) + (f/* sign adjusted-decimal)))) _ - (#e.Error ("lux text concat" <error> repr)))) + (#error.Error ("lux text concat" <error> repr)))) _ - (#e.Error ("lux text concat" <error> repr)))))] + (#error.Error ("lux text concat" <error> repr)))))] - [Binary@Codec<Text,Frac> Binary@Codec<Text,Int> 2.0 "01" "Invalid binary syntax: "] + [Binary@Codec<Text,Frac> Binary@Codec<Text,Int> +2.0 "01" "Invalid binary syntax: "] ) (def: (segment-digits chunk-size digits) @@ -483,7 +496,7 @@ (list digits) (let [boundary (n/- chunk-size num-digits) chunk (maybe.assume ("lux text clip" digits boundary num-digits)) - remaining (maybe.assume ("lux text clip" digits +0 boundary))] + remaining (maybe.assume ("lux text clip" digits 0 boundary))] (list& chunk (segment-digits chunk-size remaining))))))) (def: (bin-segment-to-hex input) @@ -575,15 +588,15 @@ (do-template [<from> <from-translator> <to> <to-translator> <base-bits>] [(def: (<from> on-left? input) (-> Bit Text Text) - (let [max-num-chars (n// <base-bits> +64) + (let [max-num-chars (n// <base-bits> 64) input-size ("lux text size" input) zero-padding (let [num-digits-that-need-padding (n/% <base-bits> input-size)] - (if (n/= +0 num-digits-that-need-padding) + (if (n/= 0 num-digits-that-need-padding) "" (loop [zeroes-left (n/- num-digits-that-need-padding <base-bits>) output ""] - (if (n/= +0 zeroes-left) + (if (n/= 0 zeroes-left) output (recur (dec zeroes-left) ("lux text concat" "0" output)))))) @@ -597,12 +610,12 @@ (def: <to> (-> Text Text) - (|>> (segment-digits +1) + (|>> (segment-digits 1) (map <to-translator>) re-join-chunks))] - [binary-to-hex bin-segment-to-hex hex-to-binary hex-segment-to-bin +4] - [binary-to-octal bin-segment-to-octal octal-to-binary octal-segment-to-bin +3] + [binary-to-hex bin-segment-to-hex hex-to-binary hex-segment-to-bin 4] + [binary-to-octal bin-segment-to-octal octal-to-binary octal-segment-to-bin 3] ) (do-template [<struct> <error> <from> <to>] @@ -610,9 +623,9 @@ (def: (encode value) (let [sign (:: Number<Frac> signum value) raw-bin (:: Binary@Codec<Text,Frac> encode value) - dot-idx (maybe.assume ("lux text index" raw-bin "." +0)) + dot-idx (maybe.assume ("lux text index" raw-bin "." 0)) whole-part (maybe.assume ("lux text clip" raw-bin - (if (f/= -1.0 sign) +1 +0) + (if (f/= -1.0 sign) 1 0) dot-idx)) decimal-part (maybe.assume ("lux text clip" raw-bin (inc dot-idx) ("lux text size" raw-bin))) hex-output (|> (<from> #0 decimal-part) @@ -622,29 +635,29 @@ hex-output)) (def: (decode repr) - (let [sign (case ("lux text index" repr "-" +0) - (#.Some +0) + (let [sign (case ("lux text index" repr "-" 0) + (#.Some 0) -1.0 _ - 1.0)] - (case ("lux text index" repr "." +0) + +1.0)] + (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)) + (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 (inc split-index) ("lux text size" repr))) as-binary (|> (<to> decimal-part) ("lux text concat" ".") ("lux text concat" (<to> whole-part)) ("lux text concat" (if (f/= -1.0 sign) "-" "")))] (case (:: Binary@Codec<Text,Frac> decode as-binary) - (#e.Error _) - (#e.Error ("lux text concat" <error> repr)) + (#error.Error _) + (#error.Error ("lux text concat" <error> repr)) output output)) _ - (#e.Error ("lux text concat" <error> repr))))))] + (#error.Error ("lux text concat" <error> repr))))))] [Octal@Codec<Text,Frac> "Invalid octaladecimal syntax: " binary-to-octal octal-to-binary] [Hex@Codec<Text,Frac> "Invalid hexadecimal syntax: " binary-to-hex hex-to-binary] @@ -661,17 +674,17 @@ description [cursor (#.Text ($_ "lux text concat" encoding "\n" underscore))]] - (#e.Success [state (list (` (doc (~ description) - (~ example-1) - (~ example-2))))])) + (#error.Success [state (list (` (doc (~ description) + (~ example-1) + (~ example-2))))])) _ - (#e.Error "Wrong syntax for \"encoding-doc\"."))) + (#error.Error "Wrong syntax for \"encoding-doc\"."))) (def: (underscore-prefixed? number) (-> Text Bit) - (case ("lux text index" number "_" +0) - (#.Some +0) + (case ("lux text index" number "_" 0) + (#.Some 0) #1 _ @@ -687,36 +700,36 @@ (case tokens (#.Cons [meta (#.Text repr')] #.Nil) (if (underscore-prefixed? repr') - (#e.Error <error>) + (#error.Error <error>) (let [repr (clean-underscores repr')] (case (:: <nat> decode repr) - (#e.Success value) - (#e.Success [state (list [meta (#.Nat value)])]) + (#error.Success value) + (#error.Success [state (list [meta (#.Nat value)])]) - (^multi (#e.Error _) - [(:: <int> decode repr) (#e.Success value)]) - (#e.Success [state (list [meta (#.Int value)])]) + (^multi (#error.Error _) + [(:: <int> decode repr) (#error.Success value)]) + (#error.Success [state (list [meta (#.Int value)])]) - (^multi (#e.Error _) - [(:: <rev> decode repr) (#e.Success value)]) - (#e.Success [state (list [meta (#.Rev value)])]) + (^multi (#error.Error _) + [(:: <rev> decode repr) (#error.Success value)]) + (#error.Success [state (list [meta (#.Rev value)])]) - (^multi (#e.Error _) - [(:: <frac> decode repr) (#e.Success value)]) - (#e.Success [state (list [meta (#.Frac value)])]) + (^multi (#error.Error _) + [(:: <frac> decode repr) (#error.Success value)]) + (#error.Success [state (list [meta (#.Frac value)])]) _ - (#e.Error <error>)))) + (#error.Error <error>)))) _ - (#e.Error <error>)))] + (#error.Error <error>)))] [bin Binary@Codec<Text,Nat> Binary@Codec<Text,Int> Binary@Codec<Text,Rev> Binary@Codec<Text,Frac> "Invalid binary syntax." - (encoding-doc "binary" (bin "11001001") (bin "11_00_10_01"))] + (encoding-doc "binary" (bin "+11001001") (bin "+11_00_10_01"))] [oct Octal@Codec<Text,Nat> Octal@Codec<Text,Int> Octal@Codec<Text,Rev> Octal@Codec<Text,Frac> "Invalid octal syntax." - (encoding-doc "octal" (oct "615243") (oct "615_243"))] + (encoding-doc "octal" (oct "+615243") (oct "+615_243"))] [hex Hex@Codec<Text,Nat> Hex@Codec<Text,Int> Hex@Codec<Text,Rev> Hex@Codec<Text,Frac> "Invalid hexadecimal syntax." (encoding-doc "hexadecimal" (hex "deadBEEF") (hex "dead_BEEF"))] @@ -740,7 +753,7 @@ (def: (digits-get idx digits) (-> Nat Digits Nat) - (maybe.default +0 ("lux array get" digits idx))) + (maybe.default 0 ("lux array get" digits idx))) (def: (digits-put idx digit digits) (-> Nat Nat Digits Digits) @@ -753,23 +766,23 @@ (def: (digits-times-5! idx output) (-> Nat Digits Digits) (loop [idx idx - carry +0 + carry 0 output output] - (if (i/>= 0 (:coerce Int idx)) + (if (i/>= +0 (:coerce Int idx)) (let [raw (|> (digits-get idx output) - (n/* +5) + (n/* 5) (n/+ carry))] (recur (dec idx) - (n// +10 raw) - (digits-put idx (n/% +10 raw) output))) + (n// 10 raw) + (digits-put idx (n/% 10 raw) output))) output))) (def: (digits-power power) (-> Nat Digits) (loop [times power output (|> (make-digits []) - (digits-put power +1))] - (if (i/>= 0 (:coerce Int times)) + (digits-put power 1))] + (if (i/>= +0 (:coerce Int times)) (recur (dec times) (digits-times-5! power output)) output))) @@ -779,9 +792,9 @@ (loop [idx (dec i64.width) all-zeroes? #1 output ""] - (if (i/>= 0 (:coerce Int idx)) + (if (i/>= +0 (:coerce Int idx)) (let [digit (digits-get idx digits)] - (if (and (n/= +0 digit) + (if (and (n/= 0 digit) all-zeroes?) (recur (dec idx) #1 output) (recur (dec idx) @@ -796,27 +809,27 @@ (def: (digits-add param subject) (-> Digits Digits Digits) (loop [idx (dec i64.width) - carry +0 + carry 0 output (make-digits [])] - (if (i/>= 0 (:coerce Int idx)) + (if (i/>= +0 (:coerce Int idx)) (let [raw ($_ n/+ carry (digits-get idx param) (digits-get idx subject))] (recur (dec idx) - (n// +10 raw) - (digits-put idx (n/% +10 raw) output))) + (n// 10 raw) + (digits-put idx (n/% 10 raw) output))) output))) (def: (text-to-digits input) (-> Text (Maybe Digits)) (let [length ("lux text size" input)] (if (n/<= i64.width length) - (loop [idx +0 + (loop [idx 0 output (make-digits [])] (if (n/< length idx) (let [char (maybe.assume (get-char input idx))] - (case ("lux text index" "0123456789" char +0) + (case ("lux text index" "+0123456789" char 0) #.None #.None @@ -828,7 +841,7 @@ (def: (digits-lt param subject) (-> Digits Digits Bit) - (loop [idx +0] + (loop [idx 0] (and (n/< i64.width idx) (let [pd (digits-get idx param) sd (digits-get idx subject)] @@ -842,17 +855,17 @@ (if (n/>= param sd) (digits-put idx (n/- param sd) subject) (let [diff (|> sd - (n/+ +10) + (n/+ 10) (n/- param))] (|> subject (digits-put idx diff) - (digits-sub-once! (dec idx) +1)))))) + (digits-sub-once! (dec idx) 1)))))) (def: (digits-sub! param subject) (-> Digits Digits Digits) (loop [idx (dec i64.width) output subject] - (if (i/>= 0 (.int idx)) + (if (i/>= +0 (.int idx)) (recur (dec idx) (digits-sub-once! idx (digits-get idx param) output)) output))) @@ -861,11 +874,11 @@ (def: (encode input) (let [input (:coerce Nat input) last-idx (dec i64.width)] - (if (n/= +0 input) + (if (n/= 0 input) ".0" (loop [idx last-idx digits (make-digits [])] - (if (i/>= 0 (:coerce Int idx)) + (if (i/>= +0 (:coerce Int idx)) (if (i64.set? idx input) (let [digits' (digits-add (digits-power (n/- idx last-idx)) digits)] @@ -878,21 +891,21 @@ (def: (decode input) (let [length ("lux text size" input) - dotted? (case ("lux text index" input "." +0) - (#.Some +0) + dotted? (case ("lux text index" input "." 0) + (#.Some 0) #1 _ #0)] (if (and dotted? (n/<= (inc i64.width) length)) - (case (|> ("lux text clip" input +1 length) + (case (|> ("lux text clip" input 1 length) maybe.assume text-to-digits) (#.Some digits) (loop [digits digits - idx +0 - output +0] + idx 0 + output 0] (if (n/< i64.width idx) (let [power (digits-power idx)] (if (digits-lt power digits) @@ -901,70 +914,70 @@ (recur (digits-sub! power digits) (inc idx) (i64.set (n/- idx (dec i64.width)) output)))) - (#e.Success (:coerce Rev output)))) + (#error.Success (:coerce Rev output)))) #.None - (#e.Error ("lux text concat" "Wrong syntax for Rev: " input))) - (#e.Error ("lux text concat" "Wrong syntax for Rev: " input)))) + (#error.Error ("lux text concat" "Wrong syntax for Rev: " input))) + (#error.Error ("lux text concat" "Wrong syntax for Rev: " input)))) )) (def: (log2 input) (-> Frac Frac) - (f// ("lux math log" 2.0) + (f// ("lux math log" +2.0) ("lux math log" input))) -(def: double-bias Nat +1023) +(def: double-bias Nat 1023) -(def: mantissa-size Nat +52) -(def: exponent-size Nat +11) +(def: mantissa-size Nat 52) +(def: exponent-size Nat 11) (def: #export (frac-to-bits input) (-> Frac I64) (i64 (cond (not-a-number? input) - (hex "+7FF7FFFFFFFFFFFF") + (hex "7FF7FFFFFFFFFFFF") (f/= positive-infinity input) - (hex "+7FF0000000000000") + (hex "7FF0000000000000") (f/= negative-infinity input) - (hex "+FFF0000000000000") + (hex "FFF0000000000000") - (f/= 0.0 input) - (let [reciprocal (f// input 1.0)] + (f/= +0.0 input) + (let [reciprocal (f// input +1.0)] (if (f/= positive-infinity reciprocal) ## Positive zero - (hex "+0000000000000000") + (hex "0000000000000000") ## Negative zero - (hex "+8000000000000000"))) + (hex "8000000000000000"))) ## else (let [sign (:: Number<Frac> signum input) input (:: Number<Frac> abs input) exponent ("lux math floor" (log2 input)) - exponent-mask (|> +1 (i64.left-shift exponent-size) dec) + exponent-mask (|> 1 (i64.left-shift exponent-size) dec) mantissa (|> input ## Normalize - (f// ("lux math pow" 2.0 exponent)) + (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) + (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) (i64.and exponent-mask)) mantissa-bits (|> mantissa frac-to-int .nat)] ($_ i64.or - (i64.left-shift +63 sign-bit) + (i64.left-shift 63 sign-bit) (i64.left-shift mantissa-size exponent-bits) (i64.clear mantissa-size mantissa-bits))) ))) (do-template [<getter> <mask> <size> <offset>] - [(def: <mask> (|> +1 (i64.left-shift <size>) dec (i64.left-shift <offset>))) + [(def: <mask> (|> 1 (i64.left-shift <size>) dec (i64.left-shift <offset>))) (def: (<getter> input) (-> (I64 Any) I64) (|> input (i64.and <mask>) (i64.logical-right-shift <offset>) i64))] - [mantissa mantissa-mask mantissa-size +0] + [mantissa mantissa-mask mantissa-size 0] [exponent exponent-mask exponent-size mantissa-size] - [sign sign-mask +1 (n/+ exponent-size mantissa-size)] + [sign sign-mask 1 (n/+ exponent-size mantissa-size)] ) (def: #export (bits-to-frac input) @@ -972,28 +985,28 @@ (let [S (sign input) E (exponent input) M (mantissa input)] - (cond (n/= (hex "+7FF") E) - (if (n/= +0 M) - (if (n/= +0 S) + (cond (n/= (hex "7FF") E) + (if (n/= 0 M) + (if (n/= 0 S) positive-infinity negative-infinity) not-a-number) - (and (n/= +0 E) (n/= +0 M)) - (if (n/= +0 S) - 0.0 - (f/* -1.0 0.0)) + (and (n/= 0 E) (n/= 0 M)) + (if (n/= 0 S) + +0.0 + (f/* -1.0 +0.0)) ## else (let [normalized (|> M (i64.set mantissa-size) .int int-to-frac - (f// ("lux math pow" 2.0 52.0))) + (f// ("lux math pow" +2.0 +52.0))) power (|> E (n/- double-bias) .int int-to-frac - ("lux math pow" 2.0)) + ("lux math pow" +2.0)) shifted (f/* power normalized)] - (if (n/= +0 S) + (if (n/= 0 S) shifted (f/* -1.0 shifted)))))) diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux index cc725925b..cd785fb31 100644 --- a/stdlib/source/lux/data/number/complex.lux +++ b/stdlib/source/lux/data/number/complex.lux @@ -27,14 +27,14 @@ "The imaginary part can be omitted if it's 0." (complex real))} (wrap (list (` {#..real (~ real) - #..imaginary (~ (maybe.default (' 0.0) + #..imaginary (~ (maybe.default (' +0.0) ?imaginary))})))) -(def: #export i Complex (complex 0.0 1.0)) +(def: #export i Complex (complex +0.0 +1.0)) -(def: #export one Complex (complex 1.0 0.0)) +(def: #export one Complex (complex +1.0 +0.0)) -(def: #export zero Complex (complex 0.0 0.0)) +(def: #export zero Complex (complex +0.0 +0.0)) (def: #export (not-a-number? complex) (or (number.not-a-number? (get@ #real complex)) @@ -158,8 +158,8 @@ (def: #export (tan subject) (-> Complex Complex) (let [(^slots [#real #imaginary]) subject - r2 (f/* 2.0 real) - i2 (f/* 2.0 imaginary) + r2 (f/* +2.0 real) + i2 (f/* +2.0 imaginary) d (f/+ (math.cos r2) (math.cosh i2))] {#real (f// d (math.sin r2)) #imaginary (f// d (math.sinh i2))})) @@ -167,8 +167,8 @@ (def: #export (tanh subject) (-> Complex Complex) (let [(^slots [#real #imaginary]) subject - r2 (f/* 2.0 real) - i2 (f/* 2.0 imaginary) + r2 (f/* +2.0 real) + i2 (f/* +2.0 imaginary) d (f/+ (math.cosh r2) (math.cos i2))] {#real (f// d (math.sinh r2)) #imaginary (f// d (math.sin i2))})) @@ -178,15 +178,15 @@ (let [(^slots [#real #imaginary]) subject] (complex (if (f/< (frac/abs imaginary) (frac/abs real)) - (if (f/= 0.0 imaginary) + (if (f/= +0.0 imaginary) (frac/abs real) (let [q (f// imaginary real)] - (f/* (math.pow 0.5 (f/+ 1.0 (f/* q q))) + (f/* (math.pow +0.5 (f/+ +1.0 (f/* q q))) (frac/abs imaginary)))) - (if (f/= 0.0 real) + (if (f/= +0.0 real) (frac/abs imaginary) (let [q (f// real imaginary)] - (f/* (math.pow 0.5 (f/+ 1.0 (f/* q q))) + (f/* (math.pow +0.5 (f/+ +1.0 (f/* q q))) (frac/abs real)))) )))) @@ -234,18 +234,18 @@ (def: #export (root2 (^@ input (^slots [#real #imaginary]))) (-> Complex Complex) - (let [t (|> input ..abs (get@ #real) (f/+ (frac/abs real)) (f// 2.0) (math.pow 0.5))] - (if (f/>= 0.0 real) + (let [t (|> input ..abs (get@ #real) (f/+ (frac/abs real)) (f// +2.0) (math.pow +0.5))] + (if (f/>= +0.0 real) {#real t - #imaginary (f// (f/* 2.0 t) + #imaginary (f// (f/* +2.0 t) imaginary)} - {#real (f// (f/* 2.0 t) + {#real (f// (f/* +2.0 t) (frac/abs imaginary)) - #imaginary (f/* t (copy-sign imaginary 1.0))}))) + #imaginary (f/* t (copy-sign imaginary +1.0))}))) (def: #export (root2-1z input) (-> Complex Complex) - (|> (complex 1.0) (- (* input input)) root2)) + (|> (complex +1.0) (- (* input input)) root2)) (def: #export (reciprocal (^slots [#real #imaginary])) (-> Complex Complex) @@ -253,12 +253,12 @@ (frac/abs real)) (let [q (f// imaginary real) scale (f// (|> real (f/* q) (f/+ imaginary)) - 1.0)] + +1.0)] {#real (f/* q scale) #imaginary (frac/negate scale)}) (let [q (f// real imaginary) scale (f// (|> imaginary (f/* q) (f/+ real)) - 1.0)] + +1.0)] {#real scale #imaginary (|> scale frac/negate (f/* q))}))) @@ -283,7 +283,7 @@ (+ i) (/ (- input i)) log - (* (/ (complex 2.0) i)))) + (* (/ (complex +2.0) i)))) (def: #export (argument (^slots [#real #imaginary])) (-> Complex Frac) @@ -291,13 +291,13 @@ (def: #export (roots nth input) (-> Nat Complex (List Complex)) - (if (n/= +0 nth) + (if (n/= 0 nth) (list) (let [r-nth (|> nth .int int-to-frac) - nth-root-of-abs (|> input abs (get@ #real) (math.pow (f// r-nth 1.0))) + nth-root-of-abs (|> input 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 (dec nth)) + slice (|> math.pi (f/* +2.0) (f// r-nth))] + (|> (list.n/range 0 (dec nth)) (list/map (function (_ nth') (let [inner (|> nth' .int int-to-frac (f/* slice) diff --git a/stdlib/source/lux/data/number/i64.lux b/stdlib/source/lux/data/number/i64.lux index 32b9df2e3..aba61ad3e 100644 --- a/stdlib/source/lux/data/number/i64.lux +++ b/stdlib/source/lux/data/number/i64.lux @@ -1,6 +1,6 @@ (.module: [lux (#- and or not)]) -(def: #export width Nat +64) +(def: #export width Nat 64) ## [Values] (do-template [<name> <op> <doc>] @@ -32,15 +32,15 @@ (def: #export (count subject) {#.doc "Count the number of 1s in a bit-map."} (-> (I64 Any) Nat) - (let [count' (n/- (|> subject (logical-right-shift +1) (..and +6148914691236517205) i64) + (let [count' (n/- (|> subject (logical-right-shift 1) (..and 6148914691236517205) i64) (i64 subject))] (|> count' - (logical-right-shift +2) (..and +3689348814741910323) (n/+ (..and +3689348814741910323 count')) - (add-shift +4) (..and +1085102592571150095) - (add-shift +8) - (add-shift +16) - (add-shift +32) - (..and +127)))) + (logical-right-shift 2) (..and 3689348814741910323) (n/+ (..and 3689348814741910323 count')) + (add-shift 4) (..and 1085102592571150095) + (add-shift 8) + (add-shift 16) + (add-shift 32) + (..and 127)))) (def: #export not {#.doc "Bitwise negation."} @@ -49,7 +49,7 @@ (def: (flag idx) (-> Nat I64) - (|> +1 (:coerce I64) (left-shift idx))) + (|> 1 (:coerce I64) (left-shift idx))) (def: #export (clear idx input) {#.doc "Clear bit at given index."} @@ -68,7 +68,7 @@ (def: #export (set? idx input) (-> Nat (I64 Any) Bit) - (|> input (:coerce I64) (..and (flag idx)) (n/= +0) .not)) + (|> input (:coerce I64) (..and (flag idx)) (n/= 0) .not)) (do-template [<name> <main> <comp>] [(def: #export (<name> distance input) @@ -84,4 +84,4 @@ (def: #export (region size offset) (-> Nat Nat I64) - (|> +1 (:coerce I64) (left-shift size) dec (left-shift offset))) + (|> 1 (:coerce I64) (left-shift size) dec (left-shift offset))) diff --git a/stdlib/source/lux/data/number/ratio.lux b/stdlib/source/lux/data/number/ratio.lux index 0562dec72..647eaf4b5 100644 --- a/stdlib/source/lux/data/number/ratio.lux +++ b/stdlib/source/lux/data/number/ratio.lux @@ -123,18 +123,14 @@ #denominator numerator}) (def: abs id) (def: (signum x) - {#numerator +1 - #denominator +1})) + {#numerator 1 + #denominator 1})) (def: separator Text ":") (def: part-encode (-> Nat Text) - (|>> nat/encode (text.split +1) maybe.assume product.right)) - -(def: part-decode - (-> Text (E.Error Nat)) - (|>> (format "+") nat/decode)) + (|>> nat/encode (text.split 1) maybe.assume product.right)) (structure: #export _ (Codec Text Ratio) (def: (encode (^slots [#numerator #denominator])) @@ -144,8 +140,8 @@ (case (text.split-with separator input) (#.Some [num denom]) (do E.Monad<Error> - [numerator (part-decode num) - denominator (part-decode denom)] + [numerator (nat/decode num) + denominator (nat/decode denom)] (wrap (normalize {#numerator numerator #denominator denominator}))) @@ -158,5 +154,5 @@ "The denominator can be omitted if it's 1." (ratio numerator))} (wrap (list (` ((~! normalize) {#..numerator (~ numerator) - #..denominator (~ (maybe.default (' +1) + #..denominator (~ (maybe.default (' 1) ?denominator))}))))) diff --git a/stdlib/source/lux/data/sum.lux b/stdlib/source/lux/data/sum.lux index 670951182..edb9d19fd 100644 --- a/stdlib/source/lux/data/sum.lux +++ b/stdlib/source/lux/data/sum.lux @@ -7,8 +7,8 @@ (All [a b] (-> <type> (| a b))) (<index> value))] - [left a +0] - [right b +1]) + [left a 0] + [right b 1]) (def: #export (either fl fr) (All [a b c] @@ -16,8 +16,8 @@ (-> (| a b) c))) (function (_ input) (case input - (+0 l) (fl l) - (+1 r) (fr r)))) + (0 l) (fl l) + (1 r) (fr r)))) (def: #export (each fl fr) (All [l l' r r'] @@ -25,8 +25,8 @@ (-> (| l r) (| l' r')))) (function (_ input) (case input - (+0 l) (+0 (fl l)) - (+1 r) (+1 (fr r))))) + (0 l) (0 (fl l)) + (1 r) (1 (fr r))))) (do-template [<name> <side> <tag>] [(def: #export (<name> es) @@ -36,8 +36,8 @@ (#.Cons (<tag> x) es') (#.Cons [x (<name> es')]) (#.Cons _ es') (<name> es')))] - [lefts a +0] - [rights b +1] + [lefts a 0] + [rights b 1] ) (def: #export (partition xs) @@ -49,5 +49,5 @@ (#.Cons x xs') (let [[lefts rights] (partition xs')] (case x - (+0 x') [(#.Cons x' lefts) rights] - (+1 x') [lefts (#.Cons x' rights)])))) + (0 x') [(#.Cons x' lefts) rights] + (1 x') [lefts (#.Cons x' rights)])))) diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux index 28679b429..48f35febe 100644 --- a/stdlib/source/lux/data/text.lux +++ b/stdlib/source/lux/data/text.lux @@ -30,7 +30,7 @@ (def: #export (index-of pattern input) (-> Text Text (Maybe Nat)) - ("lux text index" input pattern +0)) + ("lux text index" input pattern 0)) (def: (last-index-of'' part since text) (-> Text Nat Text (Maybe Nat)) @@ -52,7 +52,7 @@ (def: #export (last-index-of part text) (-> Text Text (Maybe Nat)) - (case ("lux text index" text part +0) + (case ("lux text index" text part 0) (#.Some since) (last-index-of'' part since text) @@ -62,7 +62,7 @@ (def: #export (starts-with? prefix x) (-> Text Text Bit) (case (index-of prefix x) - (#.Some +0) + (#.Some 0) #1 _ @@ -80,7 +80,7 @@ (def: #export (contains? sub text) (-> Text Text Bit) - (case ("lux text index" text sub +0) + (case ("lux text index" text sub 0) (#.Some _) #1 @@ -97,7 +97,7 @@ (def: #export (split at x) (-> Nat Text (Maybe [Text Text])) - (case [(..clip +0 at x) (..clip' at x)] + (case [(..clip 0 at x) (..clip' at x)] [(#.Some pre) (#.Some post)] (#.Some [pre post]) @@ -179,13 +179,13 @@ (:coerce Nat))} ## Platform-independent default. (let [length ("lux text size" input)] - (loop [idx +0 - hash +0] + (loop [idx 0 + hash 0] (if (n/< length idx) - (let [char (|> idx ("lux text char" input) (maybe.default +0))] + (let [char (|> idx ("lux text char" input) (maybe.default 0))] (recur (inc idx) (|> hash - (i64.left-shift +5) + (i64.left-shift 5) (n/- hash) (n/+ char)))) hash))))))) diff --git a/stdlib/source/lux/data/text/buffer.lux b/stdlib/source/lux/data/text/buffer.lux index f8042abc0..38b47e875 100644 --- a/stdlib/source/lux/data/text/buffer.lux +++ b/stdlib/source/lux/data/text/buffer.lux @@ -34,7 +34,7 @@ (def: #export empty Buffer (:abstraction (for {(~~ (static _.jvm)) - [+0 id]} + [0 id]} ## default row.empty))) @@ -59,7 +59,7 @@ ## default (row/fold (function (_ chunk total) (n/+ (//.size chunk) total)) - +0 + 0 (:representation buffer)))) (def: #export (text buffer) diff --git a/stdlib/source/lux/data/text/lexer.lux b/stdlib/source/lux/data/text/lexer.lux index 6e16ee6ec..481d17b0a 100644 --- a/stdlib/source/lux/data/text/lexer.lux +++ b/stdlib/source/lux/data/text/lexer.lux @@ -15,7 +15,7 @@ (type: Offset Nat) -(def: start-offset Offset +0) +(def: start-offset Offset 0) (type: #export Lexer (p.Parser [Offset Text])) @@ -126,7 +126,7 @@ (-> Nat Nat (Lexer Text)) (do p.Monad<Parser> [char any - #let [char' (maybe.assume (text.nth +0 char))] + #let [char' (maybe.assume (text.nth 0 char))] _ (p.assert ($_ text/compose "Character is not within range: " (text.from-code bottom) "-" (text.from-code top)) (.and (n/>= bottom char') (n/<= top char')))] diff --git a/stdlib/source/lux/data/text/regex.lux b/stdlib/source/lux/data/text/regex.lux index 2e4087b23..ffd937d8e 100644 --- a/stdlib/source/lux/data/text/regex.lux +++ b/stdlib/source/lux/data/text/regex.lux @@ -81,9 +81,9 @@ (def: re-range^ (l.Lexer Code) (do p.Monad<Parser> - [from (|> regex-char^ (:: @ map (|>> (text.nth +0) maybe.assume))) + [from (|> regex-char^ (:: @ map (|>> (text.nth 0) maybe.assume))) _ (l.this "-") - to (|> regex-char^ (:: @ map (|>> (text.nth +0) maybe.assume)))] + to (|> regex-char^ (:: @ map (|>> (text.nth 0) maybe.assume)))] (wrap (` (l.range (~ (code.nat from)) (~ (code.nat to))))))) (def: re-char^ @@ -183,8 +183,7 @@ (def: number^ (l.Lexer Nat) (|> (l.many l.decimal) - (p.codec number.Codec<Text,Int>) - (parser/map .nat))) + (p.codec number.Codec<Text,Nat>))) (def: re-back-reference^ (l.Lexer Code) @@ -289,7 +288,7 @@ #.None [(inc idx) (code.identifier ["" (int/encode idx)])]) - access (if (n/> +0 num-captures) + access (if (n/> 0 num-captures) (` ((~! product.left) (~ name!))) name!)] [idx! @@ -298,13 +297,13 @@ (' #let) (` [(~ g!total) (:: (~! text.Monoid<Text>) (~' compose) (~ g!total) (~ access))])) steps)]) ))) - [0 + [+0 (: (List Code) (list)) (: (List (List Code)) (list))] parts)]] (wrap [(if capturing? (list.size names) - +0) + 0) (` (do p.Monad<Parser> [(~ (' #let)) [(~ g!total) ""] (~+ (|> steps list.reverse list/join))] @@ -320,12 +319,12 @@ (function (_ input) (case (left input) (#e.Success [input' [lt lv]]) - (#e.Success [input' [lt (+0 lv)]]) + (#e.Success [input' [lt (0 lv)]]) (#e.Error _) (case (right input) (#e.Success [input' [rt rv]]) - (#e.Success [input' [rt (+1 rv)]]) + (#e.Success [input' [rt (1 rv)]]) (#e.Error error) (#e.Error error))))) @@ -347,7 +346,7 @@ (def: (prep-alternative [num-captures alt]) (-> [Nat Code] Code) - (if (n/> +0 num-captures) + (if (n/> 0 num-captures) alt (` ((~! unflatten^) (~ alt))))) diff --git a/stdlib/source/lux/data/text/unicode.lux b/stdlib/source/lux/data/text/unicode.lux index c9796158d..011af390e 100644 --- a/stdlib/source/lux/data/text/unicode.lux +++ b/stdlib/source/lux/data/text/unicode.lux @@ -59,128 +59,128 @@ (do-template [<name> <start> <end>] [(def: #export <name> Segment (..segment (hex <start>) (hex <end>)))] - [basic-latin "+0000" "+007F"] - [latin-1-supplement "+00A0" "+00FF"] - [latin-extended-a "+0100" "+017F"] - [latin-extended-b "+0180" "+024F"] - [ipa-extensions "+0250" "+02AF"] - [spacing-modifier-letters "+02B0" "+02FF"] - [combining-diacritical-marks "+0300" "+036F"] - [greek-and-coptic "+0370" "+03FF"] - [cyrillic "+0400" "+04FF"] - [cyrillic-supplementary "+0500" "+052F"] - [armenian "+0530" "+058F"] - [hebrew "+0590" "+05FF"] - [arabic "+0600" "+06FF"] - [syriac "+0700" "+074F"] - [thaana "+0780" "+07BF"] - [devanagari "+0900" "+097F"] - [bengali "+0980" "+09FF"] - [gurmukhi "+0A00" "+0A7F"] - [gujarati "+0A80" "+0AFF"] - [oriya "+0B00" "+0B7F"] - [tamil "+0B80" "+0BFF"] - [telugu "+0C00" "+0C7F"] - [kannada "+0C80" "+0CFF"] - [malayalam "+0D00" "+0D7F"] - [sinhala "+0D80" "+0DFF"] - [thai "+0E00" "+0E7F"] - [lao "+0E80" "+0EFF"] - [tibetan "+0F00" "+0FFF"] - [myanmar "+1000" "+109F"] - [georgian "+10A0" "+10FF"] - [hangul-jamo "+1100" "+11FF"] - [ethiopic "+1200" "+137F"] - [cherokee "+13A0" "+13FF"] - [unified-canadian-aboriginal-syllabics "+1400" "+167F"] - [ogham "+1680" "+169F"] - [runic "+16A0" "+16FF"] - [tagalog "+1700" "+171F"] - [hanunoo "+1720" "+173F"] - [buhid "+1740" "+175F"] - [tagbanwa "+1760" "+177F"] - [khmer "+1780" "+17FF"] - [mongolian "+1800" "+18AF"] - [limbu "+1900" "+194F"] - [tai-le "+1950" "+197F"] - [khmer-symbols "+19E0" "+19FF"] - [phonetic-extensions "+1D00" "+1D7F"] - [latin-extended-additional "+1E00" "+1EFF"] - [greek-extended "+1F00" "+1FFF"] - [general-punctuation "+2000" "+206F"] - [superscripts-and-subscripts "+2070" "+209F"] - [currency-symbols "+20A0" "+20CF"] - [combining-diacritical-marks-for-symbols "+20D0" "+20FF"] - [letterlike-symbols "+2100" "+214F"] - [number-forms "+2150" "+218F"] - [arrows "+2190" "+21FF"] - [mathematical-operators "+2200" "+22FF"] - [miscellaneous-technical "+2300" "+23FF"] - [control-pictures "+2400" "+243F"] - [optical-character-recognition "+2440" "+245F"] - [enclosed-alphanumerics "+2460" "+24FF"] - [box-drawing "+2500" "+257F"] - [block-elements "+2580" "+259F"] - [geometric-shapes "+25A0" "+25FF"] - [miscellaneous-symbols "+2600" "+26FF"] - [dingbats "+2700" "+27BF"] - [miscellaneous-mathematical-symbols-a "+27C0" "+27EF"] - [supplemental-arrows-a "+27F0" "+27FF"] - [braille-patterns "+2800" "+28FF"] - [supplemental-arrows-b "+2900" "+297F"] - [miscellaneous-mathematical-symbols-b "+2980" "+29FF"] - [supplemental-mathematical-operators "+2A00" "+2AFF"] - [miscellaneous-symbols-and-arrows "+2B00" "+2BFF"] - [cjk-radicals-supplement "+2E80" "+2EFF"] - [kangxi-radicals "+2F00" "+2FDF"] - [ideographic-description-characters "+2FF0" "+2FFF"] - [cjk-symbols-and-punctuation "+3000" "+303F"] - [hiragana "+3040" "+309F"] - [katakana "+30A0" "+30FF"] - [bopomofo "+3100" "+312F"] - [hangul-compatibility-jamo "+3130" "+318F"] - [kanbun "+3190" "+319F"] - [bopomofo-extended "+31A0" "+31BF"] - [katakana-phonetic-extensions "+31F0" "+31FF"] - [enclosed-cjk-letters-and-months "+3200" "+32FF"] - [cjk-compatibility "+3300" "+33FF"] - [cjk-unified-ideographs-extension-a "+3400" "+4DBF"] - [yijing-hexagram-symbols "+4DC0" "+4DFF"] - [cjk-unified-ideographs "+4E00" "+9FFF"] - [yi-syllables "+A000" "+A48F"] - [yi-radicals "+A490" "+A4CF"] - [hangul-syllables "+AC00" "+D7AF"] - [high-surrogates "+D800" "+DB7F"] - [high-private-use-surrogates "+DB80" "+DBFF"] - [low-surrogates "+DC00" "+DFFF"] - [private-use-area "+E000" "+F8FF"] - [cjk-compatibility-ideographs "+F900" "+FAFF"] - [alphabetic-presentation-forms "+FB00" "+FB4F"] - [arabic-presentation-forms-a "+FB50" "+FDFF"] - [variation-selectors "+FE00" "+FE0F"] - [combining-half-marks "+FE20" "+FE2F"] - [cjk-compatibility-forms "+FE30" "+FE4F"] - [small-form-variants "+FE50" "+FE6F"] - [arabic-presentation-forms-b "+FE70" "+FEFF"] - [halfwidth-and-fullwidth-forms "+FF00" "+FFEF"] - [specials "+FFF0" "+FFFF"] - [linear-b-syllabary "+10000" "+1007F"] - [linear-b-ideograms "+10080" "+100FF"] - [aegean-numbers "+10100" "+1013F"] - [old-italic "+10300" "+1032F"] - [gothic "+10330" "+1034F"] - [ugaritic "+10380" "+1039F"] - [deseret "+10400" "+1044F"] - [shavian "+10450" "+1047F"] - [osmanya "+10480" "+104AF"] - [cypriot-syllabary "+10800" "+1083F"] - [byzantine-musical-symbols "+1D000" "+1D0FF"] - [musical-symbols "+1D100" "+1D1FF"] - [tai-xuan-jing-symbols "+1D300" "+1D35F"] - [mathematical-alphanumeric-symbols "+1D400" "+1D7FF"] - [cjk-unified-ideographs-extension-b "+20000" "+2A6DF"] - [cjk-compatibility-ideographs-supplement "+2F800" "+2FA1F"] - [tags "+E0000" "+E007F"] + [basic-latin "0000" "007F"] + [latin-1-supplement "00A0" "00FF"] + [latin-extended-a "0100" "017F"] + [latin-extended-b "0180" "024F"] + [ipa-extensions "0250" "02AF"] + [spacing-modifier-letters "02B0" "02FF"] + [combining-diacritical-marks "0300" "036F"] + [greek-and-coptic "0370" "03FF"] + [cyrillic "0400" "04FF"] + [cyrillic-supplementary "0500" "052F"] + [armenian "0530" "058F"] + [hebrew "0590" "05FF"] + [arabic "0600" "06FF"] + [syriac "0700" "074F"] + [thaana "0780" "07BF"] + [devanagari "0900" "097F"] + [bengali "0980" "09FF"] + [gurmukhi "0A00" "0A7F"] + [gujarati "0A80" "0AFF"] + [oriya "0B00" "0B7F"] + [tamil "0B80" "0BFF"] + [telugu "0C00" "0C7F"] + [kannada "0C80" "0CFF"] + [malayalam "0D00" "0D7F"] + [sinhala "0D80" "0DFF"] + [thai "0E00" "0E7F"] + [lao "0E80" "0EFF"] + [tibetan "0F00" "0FFF"] + [myanmar "1000" "109F"] + [georgian "10A0" "10FF"] + [hangul-jamo "1100" "11FF"] + [ethiopic "1200" "137F"] + [cherokee "13A0" "13FF"] + [unified-canadian-aboriginal-syllabics "1400" "167F"] + [ogham "1680" "169F"] + [runic "16A0" "16FF"] + [tagalog "1700" "171F"] + [hanunoo "1720" "173F"] + [buhid "1740" "175F"] + [tagbanwa "1760" "177F"] + [khmer "1780" "17FF"] + [mongolian "1800" "18AF"] + [limbu "1900" "194F"] + [tai-le "1950" "197F"] + [khmer-symbols "19E0" "19FF"] + [phonetic-extensions "1D00" "1D7F"] + [latin-extended-additional "1E00" "1EFF"] + [greek-extended "1F00" "1FFF"] + [general-punctuation "2000" "206F"] + [superscripts-and-subscripts "2070" "209F"] + [currency-symbols "20A0" "20CF"] + [combining-diacritical-marks-for-symbols "20D0" "20FF"] + [letterlike-symbols "2100" "214F"] + [number-forms "2150" "218F"] + [arrows "2190" "21FF"] + [mathematical-operators "2200" "22FF"] + [miscellaneous-technical "2300" "23FF"] + [control-pictures "2400" "243F"] + [optical-character-recognition "2440" "245F"] + [enclosed-alphanumerics "2460" "24FF"] + [box-drawing "2500" "257F"] + [block-elements "2580" "259F"] + [geometric-shapes "25A0" "25FF"] + [miscellaneous-symbols "2600" "26FF"] + [dingbats "2700" "27BF"] + [miscellaneous-mathematical-symbols-a "27C0" "27EF"] + [supplemental-arrows-a "27F0" "27FF"] + [braille-patterns "2800" "28FF"] + [supplemental-arrows-b "2900" "297F"] + [miscellaneous-mathematical-symbols-b "2980" "29FF"] + [supplemental-mathematical-operators "2A00" "2AFF"] + [miscellaneous-symbols-and-arrows "2B00" "2BFF"] + [cjk-radicals-supplement "2E80" "2EFF"] + [kangxi-radicals "2F00" "2FDF"] + [ideographic-description-characters "2FF0" "2FFF"] + [cjk-symbols-and-punctuation "3000" "303F"] + [hiragana "3040" "309F"] + [katakana "30A0" "30FF"] + [bopomofo "3100" "312F"] + [hangul-compatibility-jamo "3130" "318F"] + [kanbun "3190" "319F"] + [bopomofo-extended "31A0" "31BF"] + [katakana-phonetic-extensions "31F0" "31FF"] + [enclosed-cjk-letters-and-months "3200" "32FF"] + [cjk-compatibility "3300" "33FF"] + [cjk-unified-ideographs-extension-a "3400" "4DBF"] + [yijing-hexagram-symbols "4DC0" "4DFF"] + [cjk-unified-ideographs "4E00" "9FFF"] + [yi-syllables "A000" "A48F"] + [yi-radicals "A490" "A4CF"] + [hangul-syllables "AC00" "D7AF"] + [high-surrogates "D800" "DB7F"] + [high-private-use-surrogates "DB80" "DBFF"] + [low-surrogates "DC00" "DFFF"] + [private-use-area "E000" "F8FF"] + [cjk-compatibility-ideographs "F900" "FAFF"] + [alphabetic-presentation-forms "FB00" "FB4F"] + [arabic-presentation-forms-a "FB50" "FDFF"] + [variation-selectors "FE00" "FE0F"] + [combining-half-marks "FE20" "FE2F"] + [cjk-compatibility-forms "FE30" "FE4F"] + [small-form-variants "FE50" "FE6F"] + [arabic-presentation-forms-b "FE70" "FEFF"] + [halfwidth-and-fullwidth-forms "FF00" "FFEF"] + [specials "FFF0" "FFFF"] + [linear-b-syllabary "10000" "1007F"] + [linear-b-ideograms "10080" "100FF"] + [aegean-numbers "10100" "1013F"] + [old-italic "10300" "1032F"] + [gothic "10330" "1034F"] + [ugaritic "10380" "1039F"] + [deseret "10400" "1044F"] + [shavian "10450" "1047F"] + [osmanya "10480" "104AF"] + [cypriot-syllabary "10800" "1083F"] + [byzantine-musical-symbols "1D000" "1D0FF"] + [musical-symbols "1D100" "1D1FF"] + [tai-xuan-jing-symbols "1D300" "1D35F"] + [mathematical-alphanumeric-symbols "1D400" "1D7FF"] + [cjk-unified-ideographs-extension-b "20000" "2A6DF"] + [cjk-compatibility-ideographs-supplement "2F800" "2FA1F"] + [tags "E0000" "E007F"] ) (type: #export Set (Tree Segment [])) @@ -203,7 +203,7 @@ (..singleton (:: Monoid<Segment> compose left right)) _ - (let [[sides extra] (n//% +2 (list.size segments)) + (let [[sides extra] (n//% 2 (list.size segments)) [left+ right+] (list.split (n/+ sides extra) segments)] (finger.branch (set left+) (set right+))))) diff --git a/stdlib/source/lux/host.js.lux b/stdlib/source/lux/host.js.lux index d074b1ff1..0302064b3 100644 --- a/stdlib/source/lux/host.js.lux +++ b/stdlib/source/lux/host.js.lux @@ -30,7 +30,7 @@ ## [Syntax] (syntax: #export (set! field-name field-value object) {#.doc (doc "A way to set fields from objects." - (set! "foo" 1234 some-object))} + (set! "foo" +1234 some-object))} (wrap (list (` ("js set-field" (~ object) (~ field-name) (~ field-value)))))) (syntax: #export (delete! field-name object) @@ -75,8 +75,8 @@ (syntax: #export (call! {shape (p.or ($_ p.and s.any (s.tuple (p.some s.any)) (p.maybe s.any)) ($_ p.and s.any s.text (s.tuple (p.some s.any)) (p.maybe s.any)))}) {#.doc (doc "A way to call JavaScript functions and methods." - (call! (ref "Math.ceil") [123.45]) - (call! (ref "Math") "ceil" [123.45]))} + (call! (ref "Math.ceil") [+123.45]) + (call! (ref "Math") "ceil" [+123.45]))} (case shape (#.Left [function args ?type]) (wrap (list (` (:coerce (~ (default (' ..Object) ?type)) diff --git a/stdlib/source/lux/host.jvm.lux b/stdlib/source/lux/host.jvm.lux index cd0eaafed..5b91fc526 100644 --- a/stdlib/source/lux/host.jvm.lux +++ b/stdlib/source/lux/host.jvm.lux @@ -1921,7 +1921,7 @@ {type (generic-type^ imports (list))} size) {#.doc (doc "Create an array of the given type, with the given size." - (array Object +10))} + (array Object 10))} (case type (^template [<type> <array-op>] (^ (#GenericClass <type> (list))) @@ -1967,7 +1967,7 @@ (syntax: #export (array-read idx array) {#.doc (doc "Loads an element from an array." - (array-read +10 my-array))} + (array-read 10 my-array))} (case array [_ (#.Identifier array-name)] (do Monad<Meta> @@ -1996,7 +1996,7 @@ (syntax: #export (array-write idx value array) {#.doc (doc "Stores an element into an array." - (array-write +10 my-object my-array))} + (array-write 10 my-object my-array))} (case array [_ (#.Identifier array-name)] (do Monad<Meta> diff --git a/stdlib/source/lux/io.lux b/stdlib/source/lux/io.lux index f772f60fa..9295795be 100644 --- a/stdlib/source/lux/io.lux +++ b/stdlib/source/lux/io.lux @@ -21,7 +21,7 @@ "Some value...")))} (case tokens (^ (list value)) - (let [blank (: Code [["" +0 +0] (#.Identifier ["" ""])])] + (let [blank (: Code [["" 0 0] (#.Identifier ["" ""])])] (#.Right [state (list (` ([(~ blank) (~ blank)] (~ value))))])) _ diff --git a/stdlib/source/lux/macro/code.lux b/stdlib/source/lux/macro/code.lux index f6896343c..f04503e2f 100644 --- a/stdlib/source/lux/macro/code.lux +++ b/stdlib/source/lux/macro/code.lux @@ -27,7 +27,7 @@ ## (Ann Cursor (Code' (Ann Cursor)))) ## [Utils] -(def: _cursor Cursor ["" +0 +0]) +(def: _cursor Cursor ["" 0 0]) ## [Functions] (do-template [<name> <type> <tag>] diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux index 97ec08ff7..135cad97e 100644 --- a/stdlib/source/lux/macro/poly.lux +++ b/stdlib/source/lux/macro/poly.lux @@ -153,7 +153,7 @@ (do p.Monad<Parser> [headT any] (let [members (<flattener> (type.un-name headT))] - (if (n/> +1 (list.size members)) + (if (n/> 1 (list.size members)) (local members poly) (p.fail (ex.construct <exception> headT))))))] @@ -166,7 +166,7 @@ (do p.Monad<Parser> [headT any #let [[num-arg bodyT] (type.flatten-univ-q (type.un-name headT))]] - (if (n/= +0 num-arg) + (if (n/= 0 num-arg) (p.fail (ex.construct not-polymorphic headT)) (wrap [num-arg bodyT])))) @@ -178,22 +178,22 @@ [num-args non-poly] (local (list headT) polymorphic') env ..env #let [funcL (label funcI) - [all-varsL env'] (loop [current-arg +0 + [all-varsL env'] (loop [current-arg 0 env' env all-varsL (: (List Code) (list))] (if (n/< num-args current-arg) - (if (n/= +0 current-arg) + (if (n/= 0 current-arg) (let [varL (label (inc funcI))] (recur (inc current-arg) (|> env' (dict.put funcI [headT funcL]) (dict.put (inc funcI) [(#.Parameter (inc funcI)) varL])) (#.Cons varL all-varsL))) - (let [partialI (|> current-arg (n/* +2) (n/+ funcI)) + (let [partialI (|> current-arg (n/* 2) (n/+ funcI)) partial-varI (inc partialI) partial-varL (label partial-varI) - partialC (` ((~ funcL) (~+ (|> (list.n/range +0 (dec num-args)) - (list/map (|>> (n/* +2) inc (n/+ funcI) label)) + partialC (` ((~ funcL) (~+ (|> (list.n/range 0 (dec num-args)) + (list/map (|>> (n/* 2) inc (n/+ funcI) label)) list.reverse))))] (recur (inc current-arg) (|> env' @@ -212,7 +212,7 @@ (do p.Monad<Parser> [headT any #let [[inputsT outputT] (type.flatten-function (type.un-name headT))]] - (if (n/> +0 (list.size inputsT)) + (if (n/> 0 (list.size inputsT)) (p.and (local inputsT in-poly) (local (list outputT) out-poly)) (p.fail (ex.construct not-function headT))))) @@ -222,7 +222,7 @@ (do p.Monad<Parser> [headT any #let [[funcT paramsT] (type.flatten-application (type.un-name headT))]] - (if (n/= +0 (list.size paramsT)) + (if (n/= 0 (list.size paramsT)) (p.fail (ex.construct not-application headT)) (local (#.Cons funcT paramsT) poly)))) @@ -242,10 +242,10 @@ (def: (adjusted-idx env idx) (-> Env Nat Nat) - (let [env-level (n// +2 (dict.size env)) - parameter-level (n// +2 idx) - parameter-idx (n/% +2 idx)] - (|> env-level dec (n/- parameter-level) (n/* +2) (n/+ parameter-idx)))) + (let [env-level (n// 2 (dict.size env)) + parameter-level (n// 2 idx) + parameter-idx (n/% 2 idx)] + (|> env-level dec (n/- parameter-level) (n/* 2) (n/+ parameter-idx)))) (def: #export parameter (Poly Code) @@ -323,8 +323,8 @@ headT any] (case (type.un-name headT) (^multi (#.Apply (#.Named ["lux" "Nothing"] _) (#.Parameter funcT-idx)) - (n/= +0 (adjusted-idx env funcT-idx)) - [(dict.get +0 env) (#.Some [self-type self-call])]) + (n/= 0 (adjusted-idx env funcT-idx)) + [(dict.get 0 env) (#.Some [self-type self-call])]) (wrap self-call) _ @@ -335,7 +335,7 @@ (do p.Monad<Parser> [env ..env [funcT argsT] (apply (p.and any (p.many any))) - _ (local (list funcT) (..parameter! +0)) + _ (local (list funcT) (..parameter! 0)) allC (let [allT (list& funcT argsT)] (|> allT (monad.map @ (function.constant ..parameter)) @@ -425,13 +425,13 @@ (#.Parameter idx) (let [idx (adjusted-idx env idx)] - (if (n/= +0 idx) + (if (n/= 0 idx) (|> (dict.get idx env) maybe.assume product.left (to-code env)) (` (.$ (~ (code.nat (dec idx))))))) (#.Apply (#.Named ["lux" "Nothing"] _) (#.Parameter idx)) (let [idx (adjusted-idx env idx)] - (if (n/= +0 idx) + (if (n/= 0 idx) (|> (dict.get idx env) maybe.assume product.left (to-code env)) (undefined))) diff --git a/stdlib/source/lux/macro/poly/equivalence.lux b/stdlib/source/lux/macro/poly/equivalence.lux index cb9280506..af714ed51 100644 --- a/stdlib/source/lux/macro/poly/equivalence.lux +++ b/stdlib/source/lux/macro/poly/equivalence.lux @@ -116,7 +116,7 @@ (do @ [g!eqs (poly.tuple (p.many Equivalence<?>)) #let [g!_ (code.local-identifier "_____________") - indices (|> (list.size g!eqs) 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-identifier) indices) g!rights (list/map (|>> nat/encode (text/compose "right") code.local-identifier) indices)]] (wrap (` (: (~ (@Equivalence inputT)) diff --git a/stdlib/source/lux/macro/poly/functor.lux b/stdlib/source/lux/macro/poly/functor.lux index d28e98337..205e78566 100644 --- a/stdlib/source/lux/macro/poly/functor.lux +++ b/stdlib/source/lux/macro/poly/functor.lux @@ -29,7 +29,7 @@ #let [num-vars (list.size varsC)] #let [@Functor (: (-> Type Code) (function (_ unwrappedT) - (if (n/= +1 num-vars) + (if (n/= 1 num-vars) (` ((~! functor.Functor) (~ (poly.to-code *env* unwrappedT)))) (let [paramsC (|> num-vars dec list.indices (list/map (|>> %n code.local-identifier)))] (` (All [(~+ paramsC)] @@ -39,7 +39,7 @@ ($_ p.either ## Type-var (do p.Monad<Parser> - [#let [varI (|> num-vars (n/* +2) dec)] + [#let [varI (|> num-vars (n/* 2) dec)] _ (poly.parameter! varI)] (wrap (` ((~ funcC) (~ valueC))))) ## Variants @@ -54,7 +54,7 @@ ## Tuples (do p.Monad<Parser> [pairsCC (: (poly.Poly (List [Code Code])) - (poly.tuple (loop [idx +0 + (poly.tuple (loop [idx 0 pairsCC (: (List [Code Code]) (list))] (p.either (let [slotC (|> idx %n (format "____________slot") code.local-identifier)] @@ -75,7 +75,7 @@ [inT+ outC] (poly.function (p.many poly.any) (Arg<?> outL)) #let [inC+ (|> (list.size inT+) dec - (list.n/range +0) + (list.n/range 0) (list/map (|>> %n (format "____________inC") code.local-identifier)))]] (wrap (` (function ((~ g!) (~+ inC+)) (let [(~ outL) ((~ valueC) (~+ inC+))] diff --git a/stdlib/source/lux/macro/poly/json.lux b/stdlib/source/lux/macro/poly/json.lux index 31ae2fdff..9eabdc816 100644 --- a/stdlib/source/lux/macro/poly/json.lux +++ b/stdlib/source/lux/macro/poly/json.lux @@ -44,12 +44,12 @@ (function (_ input) (non-rec (rec-encode non-rec) input))) -(def: low-mask Nat (|> +1 (i64.left-shift +32) dec)) -(def: high-mask Nat (|> low-mask (i64.left-shift +32))) +(def: low-mask Nat (|> 1 (i64.left-shift 32) dec)) +(def: high-mask Nat (|> low-mask (i64.left-shift 32))) (structure: _ (Codec JSON Nat) (def: (encode input) - (let [high (|> input (i64.and high-mask) (i64.logical-right-shift +32)) + (let [high (|> input (i64.and high-mask) (i64.logical-right-shift 32)) low (i64.and low-mask input)] (#//.Array (row (|> high .int int-to-frac #//.Number) (|> low .int int-to-frac #//.Number))))) @@ -59,7 +59,7 @@ (do p.Monad<Parser> [high //.number low //.number]) - (wrap (n/+ (|> high frac-to-int .nat (i64.left-shift +32)) + (wrap (n/+ (|> high frac-to-int .nat (i64.left-shift 32)) (|> low frac-to-int .nat)))))) (structure: _ (Codec JSON Int) @@ -164,7 +164,7 @@ [g!encoders (poly.tuple (p.many Codec<JSON,?>//encode)) #let [g!_ (code.local-identifier "_______") g!members (|> (list.size g!encoders) dec - (list.n/range +0) + (list.n/range 0) (list/map (|>> nat/encode code.local-identifier)))]] (wrap (` (: (~ (@JSON//encode inputT)) (function ((~ g!_) [(~+ g!members)]) diff --git a/stdlib/source/lux/math.lux b/stdlib/source/lux/math.lux index 499a83e3e..cdaf54461 100644 --- a/stdlib/source/lux/math.lux +++ b/stdlib/source/lux/math.lux @@ -19,9 +19,9 @@ Frac <value>)] - [e 2.7182818284590452354 "The base of the natural logarithm."] - [pi 3.14159265358979323846 "The ratio of a circle's circumference to its diameter."] - [tau 6.28318530717958647692 "The ratio of a circle's circumference to its radius."] + [e +2.7182818284590452354 "The base of the natural logarithm."] + [pi +3.14159265358979323846 "The ratio of a circle's circumference to its diameter."] + [tau +6.28318530717958647692 "The ratio of a circle's circumference to its radius."] ) (do-template [<name> <method>] @@ -48,8 +48,8 @@ (-> Frac Frac) (let [floored (floor input) diff (f/- floored input)] - (cond (f/> 0.5 diff) - (f/+ 1.0 floored) + (cond (f/> +0.5 diff) + (f/+ +1.0 floored) (f/< -0.5 diff) (f/+ -1.0 floored) @@ -63,22 +63,22 @@ (def: #export (atan2 param subject) (-> Frac Frac Frac) - (cond (f/> 0.0 param) + (cond (f/> +0.0 param) (atan (f// param subject)) - (f/< 0.0 param) - (if (f/>= 0.0 subject) + (f/< +0.0 param) + (if (f/>= +0.0 subject) (|> subject (f// param) atan (f/+ pi)) (|> subject (f// param) atan (f/- pi))) - ## (f/= 0.0 param) - (cond (f/> 0.0 subject) - (|> pi (f// 2.0)) + ## (f/= +0.0 param) + (cond (f/> +0.0 subject) + (|> pi (f// +2.0)) - (f/< 0.0 subject) + (f/< +0.0 subject) (|> pi (f// -2.0)) - ## (f/= 0.0 subject) + ## (f/= +0.0 subject) number.not-a-number))) (def: #export (log' base input) @@ -88,16 +88,16 @@ (def: #export (factorial n) (-> Nat Nat) - (loop [acc +1 + (loop [acc 1 n n] - (if (n/<= +1 n) + (if (n/<= 1 n) acc (recur (n/* n acc) (dec n))))) (def: #export (hypotenuse catA catB) (-> Frac Frac Frac) - (pow 0.5 (f/+ (pow 2.0 catA) - (pow 2.0 catB)))) + (pow +0.5 (f/+ (pow +2.0 catA) + (pow +2.0 catB)))) (do-template [<type> <mod> <gcd> <lcm> <zero> <*> </> <->] [(def: #export (<gcd> a b) @@ -118,8 +118,8 @@ (|> a (</> (<gcd> a b)) (<*> b)) ))] - [Nat n/mod n/gcd n/lcm +0 n/* n// n/-] - [Int i/mod i/gcd i/lcm 0 i/* i// i/-] + [Nat n/mod n/gcd n/lcm 0 n/* n// n/-] + [Int i/mod i/gcd i/lcm +0 i/* i// i/-] ) ## Hyperbolic functions @@ -127,11 +127,11 @@ (do-template [<name> <comp> <inverse>] [(def: #export (<name> x) (-> Frac Frac) - (|> (exp x) (<comp> (exp (f/* -1.0 x))) (f// 2.0))) + (|> (exp x) (<comp> (exp (f/* -1.0 x))) (f// +2.0))) (def: #export (<inverse> x) (-> Frac Frac) - (|> 2.0 (f// (|> (exp x) (<comp> (exp (f/* -1.0 x)))))))] + (|> +2.0 (f// (|> (exp x) (<comp> (exp (f/* -1.0 x)))))))] [sinh f/- csch] [cosh f/+ sech] @@ -154,7 +154,7 @@ (do-template [<name> <comp>] [(def: #export (<name> x) (-> Frac Frac) - (|> x (pow 2.0) (<comp> 1.0) (pow 0.5) (f/+ x) log))] + (|> x (pow +2.0) (<comp> +1.0) (pow +0.5) (f/+ x) log))] [asinh f/+] [acosh f/-] @@ -165,17 +165,17 @@ (-> Frac Frac) (let [x+ (|> <base> (f/+ <diff>)) x- (|> <base> (f/- <diff>))] - (|> x+ (f// x-) log (f// 2.0))))] + (|> x+ (f// x-) log (f// +2.0))))] - [atanh 1.0 x] - [acoth x 1.0] + [atanh +1.0 x] + [acoth x +1.0] ) (do-template [<name> <op>] [(def: #export (<name> x) (-> Frac Frac) - (let [x^2 (|> x (pow 2.0))] - (|> 1.0 (<op> x^2) (pow 0.5) (f/+ 1.0) (f// x) log)))] + (let [x^2 (|> x (pow +2.0))] + (|> +1.0 (<op> x^2) (pow +0.5) (f/+ +1.0) (f// x) log)))] [asech f/-] [acsch f/+] @@ -246,12 +246,12 @@ (syntax: #export (infix {expr infix^}) {#.doc (doc "Infix math syntax." - (infix [x i/* 10]) + (infix [x i/* +10]) (infix [[x i/+ y] i/* [x i/- y]]) (infix [sin [x i/+ y]]) (infix [[x n/< y] and [y n/< z]]) (infix [#and x n/< y n/< z]) - (infix [(n/* +3 +9) gcd +450]) + (infix [(n/* 3 9) gcd 450]) "The rules for infix syntax are simple." "If you want your binary function to work well with it." diff --git a/stdlib/source/lux/math/modular.lux b/stdlib/source/lux/math/modular.lux index 092b18944..ef0f36bb2 100644 --- a/stdlib/source/lux/math/modular.lux +++ b/stdlib/source/lux/math/modular.lux @@ -26,7 +26,7 @@ (def: #export (from-int value) (Ex [m] (-> Int (Error (Modulus m)))) - (if (i/= 0 value) + (if (i/= +0 value) (ex.throw zero-cannot-be-a-modulus []) (#e.Success (:abstraction value)))) @@ -52,7 +52,7 @@ (|> sample (i/- reference) (i/% (to-int modulus)) - (i/= 0))) + (i/= +0))) (syntax: #export (modulus {modulus s.int}) (case (from-int modulus) @@ -144,8 +144,8 @@ (def: (i/gcd+ a b) (-> Int Int [Int Int Int]) - (if (i/= 0 a) - [0 1 b] + (if (i/= +0 a) + [+0 +1 b] (let [[ak bk gcd] (i/gcd+ (i/% a b) a)] [(i/- (i/* ak (i// a b)) @@ -158,7 +158,7 @@ (let [[value modulus] (:representation modular) _modulus (to-int modulus) [vk mk gcd] (i/gcd+ value _modulus) - co-prime? (i/= 1 gcd)] + co-prime? (i/= +1 gcd)] (if co-prime? (#.Some (mod modulus vk)) #.None))) diff --git a/stdlib/source/lux/math/random.lux b/stdlib/source/lux/math/random.lux index 340cb1baa..fdbf202cf 100644 --- a/stdlib/source/lux/math/random.lux +++ b/stdlib/source/lux/math/random.lux @@ -88,7 +88,7 @@ (Random Bit) (function (_ prng) (let [[prng output] (prng [])] - [prng (|> output (i64.and +1) (n/= +1))]))) + [prng (|> output (i64.and 1) (n/= 1))]))) (def: #export i64 (Random I64) @@ -96,7 +96,7 @@ (let [[prng left] (prng []) [prng right] (prng [])] [prng (|> left - (i64.left-shift +32) + (i64.left-shift 32) ("lux i64 +" right))]))) (def: #export nat @@ -131,7 +131,7 @@ (def: #export (text char-gen size) (-> (Random Char) Nat (Random Text)) - (if (n/= +0 size) + (if (n/= 0 size) (:: Monad<Random> wrap "") (do Monad<Random> [x char-gen @@ -170,10 +170,10 @@ (if ? (do @ [=left left] - (wrap (+0 =left))) + (wrap (0 =left))) (do @ [=right right] - (wrap (+1 =right)))))) + (wrap (1 =right)))))) (def: #export (either left right) {#.doc "Homogeneous alternative combinator."} @@ -204,7 +204,7 @@ (do-template [<name> <type> <zero> <plus>] [(def: #export (<name> size value-gen) (All [a] (-> Nat (Random a) (Random (<type> a)))) - (if (n/> +0 size) + (if (n/> 0 size) (do Monad<Random> [x value-gen xs (<name> (dec size) value-gen)] @@ -229,7 +229,7 @@ (def: #export (set Hash<a> size value-gen) (All [a] (-> (Hash a) Nat (Random a) (Random (Set a)))) - (if (n/> +0 size) + (if (n/> 0 size) (do Monad<Random> [xs (set Hash<a> (dec size) value-gen)] (loop [_ []] @@ -243,7 +243,7 @@ (def: #export (dictionary Hash<a> size key-gen value-gen) (All [k v] (-> (Hash k) Nat (Random k) (Random v) (Random (Dictionary k v)))) - (if (n/> +0 size) + (if (n/> 0 size) (do Monad<Random> [kv (dictionary Hash<a> (dec size) key-gen value-gen)] (loop [_ []] @@ -260,7 +260,7 @@ (All [a] (-> PRNG (Random a) [PRNG a])) (calc prng)) -(def: pcg-32-magic-mult Nat +6364136223846793005) +(def: pcg-32-magic-mult Nat 6364136223846793005) (def: #export (pcg-32 [inc seed]) {#.doc "An implementation of the PCG32 algorithm. @@ -269,11 +269,11 @@ (-> [(I64 Any) (I64 Any)] PRNG) (function (_ _) [(|> seed .nat (n/* pcg-32-magic-mult) ("lux i64 +" inc) [inc] pcg-32) - (let [rot (|> seed .i64 (i64.logical-right-shift +59))] + (let [rot (|> seed .i64 (i64.logical-right-shift 59))] (|> seed - (i64.logical-right-shift +18) + (i64.logical-right-shift 18) (i64.xor seed) - (i64.logical-right-shift +27) + (i64.logical-right-shift 27) (i64.rotate-right rot) .i64))])) @@ -285,10 +285,10 @@ (function (_ _) [(let [s01 (i64.xor s0 s1)] (xoroshiro-128+ [(|> s0 - (i64.rotate-left +55) + (i64.rotate-left 55) (i64.xor s01) - (i64.xor (i64.left-shift +14 s01))) - (i64.rotate-left +36 s01)])) + (i64.xor (i64.left-shift 14 s01))) + (i64.rotate-left 36 s01)])) ("lux i64 +" s0 s1)])) (def: (swap from to vec) @@ -307,7 +307,7 @@ [rand nat] (wrap (swap idx (n/% _size rand) vec)))) row - (list.n/range +0 (dec _size)))] + (list.n/range 0 (dec _size)))] (|> _shuffle - (run (pcg-32 [+123 seed])) + (run (pcg-32 [123 seed])) product.right))) diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux index 8bb0a71a3..26e99fbce 100644 --- a/stdlib/source/lux/test.lux +++ b/stdlib/source/lux/test.lux @@ -33,12 +33,12 @@ (type: #export Test (r.Random (Promise [Counters Text]))) -(def: pcg-32-magic-inc Nat +12345) +(def: pcg-32-magic-inc Nat 12345) ## [Values] -(def: success Counters [+1 +0]) -(def: failure Counters [+0 +1]) -(def: start Counters [+0 +0]) +(def: success Counters [1 0]) +(def: failure Counters [0 1]) +(def: start Counters [0 0]) (def: (add-counters [s f] [ts tf]) (-> Counters Counters Counters) @@ -87,7 +87,7 @@ (def: failed? (-> Counters Bit) - (|>> product.right (n/> +0))) + (|>> product.right (n/> 0))) (def: #export (seed value test) (-> Seed Test Test) @@ -103,10 +103,10 @@ (def: #export (times amount test) (-> Nat Test Test) - (cond (n/= +0 amount) + (cond (n/= 0 amount) (fail "Cannot try a test 0 times.") - (n/= +1 amount) + (n/= 1 amount) test ## else @@ -126,23 +126,23 @@ (context: "Simple macros and constructs" ($_ seq (test "Can write easy loops for iterative programming." - (i/= 1000 - (loop [counter 0 - value 1] - (if (i/< 3 counter) - (recur (inc counter) (i/* 10 value)) + (i/= +1000 + (loop [counter +0 + value +1] + (if (i/< +3 counter) + (recur (inc counter) (i/* +10 value)) value)))) (test "Can create lists easily through macros." - (and (case (list 1 2 3) - (#.Cons 1 (#.Cons 2 (#.Cons 3 #.Nil))) + (and (case (list +1 +2 +3) + (#.Cons +1 (#.Cons +2 (#.Cons +3 #.Nil))) #1 _ #0) - (case (list& 1 2 3 (list 4 5 6)) - (#.Cons 1 (#.Cons 2 (#.Cons 3 (#.Cons 4 (#.Cons 5 (#.Cons 6 #.Nil)))))) + (case (list& +1 +2 +3 (list +4 +5 +6)) + (#.Cons +1 (#.Cons +2 (#.Cons +3 (#.Cons +4 (#.Cons +5 (#.Cons +6 #.Nil)))))) #1 _ @@ -167,7 +167,7 @@ "By default, random tests will be tried 100 times, you can specify the amount you want:" (context: "Addition & Substraction" - (<| (times +1234) + (<| (times 1234) (do @ [x (:: @ map <prep> rand-gen) y (:: @ map <prep> rand-gen)] @@ -177,7 +177,7 @@ "If a test fails, you'll be shown a seed that you can then use to reproduce a failing scenario." (context: "Addition & Substraction" - (<| (seed +987654321) + (<| (seed 987654321) (do @ [x (:: @ map <prep> rand-gen) y (:: @ map <prep> rand-gen)] @@ -217,8 +217,8 @@ (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")) + (%n successes) " out of " (%n (n/+ failures successes)) " tests passed." "\n" + (%n failures) " tests failed." "\n")) (syntax: #export (run) {#.doc (doc "Runs all the tests defined on the current module, and in all imported modules." @@ -235,8 +235,8 @@ (:: @ map list/join)))] (wrap (list (` (: (~! (IO Any)) ((~! io) (exec ((~! do) (~! promise.Monad<Promise>) - [(~' #let) [(~ g!total-successes) +0 - (~ g!total-failures) +0] + [(~' #let) [(~ g!total-successes) 0 + (~ g!total-failures) 0] (~+ (|> tests (list/map (function (_ [module-name test desc]) (` [(~ (code.text module-name)) (~ (code.identifier [module-name test])) (~ (code.text desc))]))) @@ -248,9 +248,9 @@ list/join))] (exec (log! ((~! success-message) (~ g!total-successes) (~ g!total-failures))) ((~! promise.future) - ((~! io.exit) (if (n/> +0 (~ g!total-failures)) - 1 - 0))))) + ((~! 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 ca5ea55b4..b902b631f 100644 --- a/stdlib/source/lux/time/date.lux +++ b/stdlib/source/lux/time/date.lux @@ -57,18 +57,18 @@ (def: (month-to-nat month) (-> Month Nat) (case month - #January +0 - #February +1 - #March +2 - #April +3 - #May +4 - #June +5 - #July +6 - #August +7 - #September +8 - #October +9 - #November +10 - #December +11)) + #January 0 + #February 1 + #March 2 + #April 3 + #May 4 + #June 5 + #July 6 + #August 7 + #September 8 + #October 9 + #November 10 + #December 11)) (structure: #export _ (Order Month) (def: eq Equivalence<Month>) @@ -142,13 +142,13 @@ (def: (day-to-nat day) (-> Day Nat) (case day - #Sunday +0 - #Monday +1 - #Tuesday +2 - #Wednesday +3 - #Thursday +4 - #Friday +5 - #Saturday +6)) + #Sunday 0 + #Monday 1 + #Tuesday 2 + #Wednesday 3 + #Thursday 4 + #Friday 5 + #Saturday 6)) (structure: #export _ (Order Day) (def: eq Equivalence<Day>) @@ -223,7 +223,7 @@ ## Based on this: https://stackoverflow.com/a/42936293/6823464 (def: (pad value) (-> Int Text) - (if (i/< 10 value) + (if (i/< +10 value) (text/compose "0" (int/encode value)) (int/encode value))) @@ -237,43 +237,43 @@ (def: lex-year (l.Lexer Int) (do p.Monad<Parser> - [sign? (p.maybe (l.this "-")) + [sign (p.or (l.this "-") (l.this "+")) raw-year (p.codec number.Codec<Text,Int> (l.many l.decimal)) - #let [signum (case sign? - #.None 1 - (#.Some _) -1)]] + #let [signum (case sign + (#.Left _) -1 + (#.Right _) +1)]] (wrap (i/* signum raw-year)))) (def: lex-section (l.Lexer Int) - (p.codec number.Codec<Text,Int> (l.exactly +2 l.decimal))) + (p.codec number.Codec<Text,Int> (l.exactly 2 l.decimal))) (def: (leap-years year) (-> Int Int) - (|> (i// 4 year) - (i/- (i// 100 year)) - (i/+ (i// 400 year)))) + (|> (i// +4 year) + (i/- (i// +100 year)) + (i/+ (i// +400 year)))) (def: normal-months (Row Nat) - (row +31 +28 +31 - +30 +31 +30 - +31 +31 +30 - +31 +30 +31)) + (row 31 28 31 + 30 31 30 + 31 31 30 + 31 30 31)) (def: leap-year-months (Row Nat) - (row.update [+1] inc normal-months)) + (row.update [1] inc normal-months)) (def: (divisible? factor input) (-> Int Int Bit) - (|> input (i/% factor) (i/= 0))) + (|> input (i/% factor) (i/= +0))) (def: (leap-year? year) (-> Int Bit) - (and (divisible? 4 year) - (or (not (divisible? 100 year)) - (divisible? 400 year)))) + (and (divisible? +4 year) + (or (not (divisible? +100 year)) + (divisible? +400 year)))) ## Based on: https://stackoverflow.com/a/3309340/6823464 (def: lex-date @@ -283,8 +283,8 @@ _ (l.this "-") utc-month lex-section _ (p.assert "Invalid month." - (and (i/>= 1 utc-month) - (i/<= 12 utc-month))) + (and (i/>= +1 utc-month) + (i/<= +12 utc-month))) #let [months (if (leap-year? utc-year) leap-year-months normal-months) @@ -294,22 +294,22 @@ _ (l.this "-") utc-day lex-section _ (p.assert "Invalid day." - (and (i/>= 1 utc-day) + (and (i/>= +1 utc-day) (i/<= (.int month-days) utc-day)))] (wrap {#year utc-year #month (case utc-month - 1 #January - 2 #February - 3 #March - 4 #April - 5 #May - 6 #June - 7 #July - 8 #August - 9 #September - 10 #October - 11 #November - 12 #December + +1 #January + +2 #February + +3 #March + +4 #April + +5 #May + +6 #June + +7 #July + +8 #August + +9 #September + +10 #October + +11 #November + +12 #December _ (undefined)) #day (.nat utc-day)}))) diff --git a/stdlib/source/lux/time/duration.lux b/stdlib/source/lux/time/duration.lux index 0588d7ba2..1abac1cc0 100644 --- a/stdlib/source/lux/time/duration.lux +++ b/stdlib/source/lux/time/duration.lux @@ -63,21 +63,21 @@ (do-template [<name> <op>] [(def: #export (<name> duration) (-> Duration Bit) - (<op> 0 (:representation duration)))] + (<op> +0 (:representation duration)))] [positive? i/>] [negative? i/<] [neutral? i/=]) ) -(def: #export empty Duration (from-millis 0)) -(def: #export milli Duration (from-millis 1)) -(def: #export second Duration (scale 1_000 milli)) -(def: #export minute Duration (scale 60 second)) -(def: #export hour Duration (scale 60 minute)) -(def: #export day Duration (scale 24 hour)) -(def: #export week Duration (scale 7 day)) -(def: #export normal-year Duration (scale 365 day)) +(def: #export empty Duration (from-millis +0)) +(def: #export milli Duration (from-millis +1)) +(def: #export second Duration (scale +1_000 milli)) +(def: #export minute Duration (scale +60 second)) +(def: #export hour Duration (scale +60 minute)) +(def: #export day Duration (scale +24 hour)) +(def: #export week Duration (scale +7 day)) +(def: #export normal-year Duration (scale +365 day)) (def: #export leap-year Duration (merge day normal-year)) (structure: #export _ (Monoid Duration) @@ -87,7 +87,7 @@ (def: (encode duration) (-> Duration Text) (if (:: Equivalence<Duration> = empty duration) - "0ms" + "+0ms" (let [signed? (negative? duration) [days time-left] [(query day duration) (frame day duration)] days (if signed? @@ -102,38 +102,44 @@ millis (to-millis time-left)] ($_ text/compose (if signed? "-" "") - (if (i/= 0 days) "" (text/compose (int/encode days) "D")) - (if (i/= 0 hours) "" (text/compose (int/encode hours) "h")) - (if (i/= 0 minutes) "" (text/compose (int/encode minutes) "m")) - (if (i/= 0 seconds) "" (text/compose (int/encode seconds) "s")) - (if (i/= 0 millis) "" (text/compose (int/encode millis) "ms")) + (if (i/= +0 days) "" (text/compose (int/encode days) "D")) + (if (i/= +0 hours) "" (text/compose (int/encode hours) "h")) + (if (i/= +0 minutes) "" (text/compose (int/encode minutes) "m")) + (if (i/= +0 seconds) "" (text/compose (int/encode seconds) "s")) + (if (i/= +0 millis) "" (text/compose (int/encode millis) "ms")) )))) (def: (lex-section suffix) (-> Text (l.Lexer Int)) (|> (p.codec number.Codec<Text,Int> (l.many l.decimal)) (p.before (p.and (l.this suffix) (p.not l.alpha))) - (p.default 0))) + (p.default +0))) (def: lex-duration (l.Lexer Duration) (do p.Monad<Parser> - [signed? (l.this? "-") - #let [sign (function (_ raw) (if signed? (i/* -1 raw) raw))] + [signed? (p.or (l.this? "-") (l.this? "+")) + #let [sign (function (_ raw) + (case signed? + (#.Left _) + (i/* -1 raw) + + (#.Right _) + raw))] utc-day (lex-section "D") utc-hour (lex-section "h") utc-minute (lex-section "m") _ (p.assert "Invalid minute." - (and (i/>= 0 utc-minute) - (i/<= 59 utc-minute))) + (and (i/>= +0 utc-minute) + (i/<= +59 utc-minute))) utc-second (lex-section "s") _ (p.assert "Invalid second." - (and (i/>= 0 utc-second) - (i/<= 59 utc-second))) + (and (i/>= +0 utc-second) + (i/<= +59 utc-second))) utc-millis (lex-section "ms") _ (p.assert "Invalid milli-seconds." - (and (i/>= 0 utc-millis) - (i/<= 999 utc-millis)))] + (and (i/>= +0 utc-millis) + (i/<= +999 utc-millis)))] (wrap (|> empty (merge (scale (sign utc-day) day)) (merge (scale (sign utc-hour) hour)) @@ -146,7 +152,7 @@ (l.run input lex-duration)) (structure: #export _ - {#.doc "For example: 15D21h14m51s827ms"} + {#.doc "For example: +15D21h14m51s827ms"} (Codec Text Duration) (def: encode encode) (def: decode decode)) diff --git a/stdlib/source/lux/time/instant.lux b/stdlib/source/lux/time/instant.lux index ea834391e..d6c506218 100644 --- a/stdlib/source/lux/time/instant.lux +++ b/stdlib/source/lux/time/instant.lux @@ -77,20 +77,20 @@ (def: #export epoch {#.doc "The instant corresponding to 1970-01-01T00:00:00Z"} Instant - (from-millis 0)) + (from-millis +0)) ## Codec::encode (def: (divisible? factor input) (-> Int Int Bit) - (|> input (i/% factor) (i/= 0))) + (|> input (i/% factor) (i/= +0))) (def: (leap-year? year) (-> Int Bit) - (and (divisible? 4 year) - (or (not (divisible? 100 year)) - (divisible? 400 year)))) + (and (divisible? +4 year) + (or (not (divisible? +100 year)) + (divisible? +400 year)))) -(def: epoch-year Int 1970) +(def: epoch-year Int +1970) (def: (find-year now) (-> Instant [Int duration.Duration]) @@ -99,7 +99,7 @@ (let [year (if (leap-year? reference) duration.leap-year duration.normal-year)] - (if (i/= 0 (duration.query year time-left)) + (if (i/= +0 (duration.query year time-left)) [reference time-left] (if (duration/>= duration.empty time-left) (recur (inc reference) (duration.merge (duration.scale -1 year) time-left)) @@ -108,36 +108,36 @@ (def: normal-months (Row Nat) - (row +31 +28 +31 - +30 +31 +30 - +31 +31 +30 - +31 +30 +31)) + (row 31 28 31 + 30 31 30 + 31 31 30 + 31 30 31)) (def: leap-year-months (Row Nat) - (row.update [+1] inc normal-months)) + (row.update [1] inc normal-months)) (def: (find-month months time) (-> (Row Nat) duration.Duration [Nat duration.Duration]) (if (duration/>= duration.empty time) (row/fold (function (_ month-days [current-month time-left]) (let [month-duration (duration.scale (.int month-days) duration.day)] - (if (i/= 0 (duration.query month-duration time-left)) + (if (i/= +0 (duration.query month-duration time-left)) [current-month time-left] [(inc current-month) (duration.merge (duration.scale -1 month-duration) time-left)]))) - [+0 time] + [0 time] months) (row/fold (function (_ month-days [current-month time-left]) (let [month-duration (duration.scale (.int month-days) duration.day)] - (if (i/= 0 (duration.query month-duration time-left)) + (if (i/= +0 (duration.query month-duration time-left)) [current-month time-left] [(dec current-month) (duration.merge month-duration time-left)]))) - [+11 time] + [11 time] (row.reverse months)))) (def: (pad value) (-> Int Text) - (if (i/< 10 value) + (if (i/< +10 value) (text/compose "0" (int/encode value)) (int/encode value))) @@ -149,48 +149,48 @@ (def: (encode-millis millis) (-> Int Text) - (cond (i/= 0 millis) "" - (i/< 10 millis) ($_ text/compose ".00" (int/encode millis)) - (i/< 100 millis) ($_ text/compose ".0" (int/encode millis)) - ## (i/< 1_000 millis) + (cond (i/= +0 millis) "" + (i/< +10 millis) ($_ text/compose ".00" (int/encode millis)) + (i/< +100 millis) ($_ text/compose ".0" (int/encode millis)) + ## (i/< +1_000 millis) ($_ text/compose "." (int/encode millis)))) (def: seconds-per-day Int (duration.query duration.second duration.day)) -(def: days-up-to-epoch Int 719468) +(def: days-up-to-epoch Int +719468) (def: (extract-date instant) (-> Instant [[Int Int Int] duration.Duration]) (let [offset (relative instant) seconds (duration.query duration.second offset) z (|> seconds (i// seconds-per-day) (i/+ days-up-to-epoch)) - era (i// 146097 - (if (i/>= 0 z) + era (i// +146097 + (if (i/>= +0 z) z - (i/- 146096 z))) - days-of-era (|> z (i/- (i/* 146097 era))) + (i/- +146096 z))) + days-of-era (|> z (i/- (i/* +146097 era))) years-of-era (|> days-of-era - (i/- (i// 1460 days-of-era)) - (i/+ (i// 36524 days-of-era)) - (i/- (i// 146096 days-of-era)) - (i// 365)) - year (|> years-of-era (i/+ (i/* 400 era))) + (i/- (i// +1460 days-of-era)) + (i/+ (i// +36524 days-of-era)) + (i/- (i// +146096 days-of-era)) + (i// +365)) + year (|> years-of-era (i/+ (i/* +400 era))) days-of-year (|> days-of-era - (i/- (|> (i/* 365 years-of-era) - (i/+ (i// 4 years-of-era)) - (i/- (i// 100 years-of-era))))) + (i/- (|> (i/* +365 years-of-era) + (i/+ (i// +4 years-of-era)) + (i/- (i// +100 years-of-era))))) day-time (duration.frame duration.day offset) days-of-year (if (duration/>= duration.empty day-time) days-of-year (dec days-of-year)) - mp (|> days-of-year (i/* 5) (i/+ 2) (i// 153)) + mp (|> days-of-year (i/* +5) (i/+ +2) (i// +153)) day (|> days-of-year - (i/- (|> mp (i/* 153) (i/+ 2) (i// 5))) - (i/+ 1)) + (i/- (|> mp (i/* +153) (i/+ +2) (i// +5))) + (i/+ +1)) month (|> mp - (i/+ (if (i/< 10 mp) - 3 + (i/+ (if (i/< +10 mp) + +3 -9))) - year (if (i/<= 2 month) + year (if (i/<= +2 month) (inc year) year)] [[year month day] @@ -218,29 +218,29 @@ (def: lex-year (l.Lexer Int) (do p.Monad<Parser> - [sign? (p.maybe (l.this "-")) + [sign (p.or (l.this "-") (l.this "+")) raw-year (p.codec number.Codec<Text,Int> (l.many l.decimal)) - #let [signum (case sign? - #.None 1 - (#.Some _) -1)]] + #let [signum (case sign + (#.Left _) -1 + (#.Right _) +1)]] (wrap (i/* signum raw-year)))) (def: lex-section (l.Lexer Int) - (p.codec number.Codec<Text,Int> (l.exactly +2 l.decimal))) + (p.codec number.Codec<Text,Int> (l.exactly 2 l.decimal))) (def: lex-millis (l.Lexer Int) - (p.either (|> (l.at-most +3 l.decimal) + (p.either (|> (l.at-most 3 l.decimal) (p.codec number.Codec<Text,Int>) (p.after (l.this "."))) - (:: p.Monad<Parser> wrap 0))) + (:: p.Monad<Parser> wrap +0))) (def: (leap-years year) (-> Int Int) - (|> (i// 4 year) - (i/- (i// 100 year)) - (i/+ (i// 400 year)))) + (|> (i// +4 year) + (i/- (i// +100 year)) + (i/+ (i// +400 year)))) ## Based on: https://stackoverflow.com/a/3309340/6823464 (def: lex-instant @@ -250,8 +250,8 @@ _ (l.this "-") utc-month lex-section _ (p.assert "Invalid month." - (and (i/>= 1 utc-month) - (i/<= 12 utc-month))) + (and (i/>= +1 utc-month) + (i/<= +12 utc-month))) #let [months (if (leap-year? utc-year) leap-year-months normal-months) @@ -261,34 +261,34 @@ _ (l.this "-") utc-day lex-section _ (p.assert "Invalid day." - (and (i/>= 1 utc-day) + (and (i/>= +1 utc-day) (i/<= (.int month-days) utc-day))) _ (l.this "T") utc-hour lex-section _ (p.assert "Invalid hour." - (and (i/>= 0 utc-hour) - (i/<= 23 utc-hour))) + (and (i/>= +0 utc-hour) + (i/<= +23 utc-hour))) _ (l.this ":") utc-minute lex-section _ (p.assert "Invalid minute." - (and (i/>= 0 utc-minute) - (i/<= 59 utc-minute))) + (and (i/>= +0 utc-minute) + (i/<= +59 utc-minute))) _ (l.this ":") utc-second lex-section _ (p.assert "Invalid second." - (and (i/>= 0 utc-second) - (i/<= 59 utc-second))) + (and (i/>= +0 utc-second) + (i/<= +59 utc-second))) utc-millis lex-millis _ (l.this "Z") #let [years-since-epoch (i/- epoch-year utc-year) previous-leap-days (i/- (leap-years epoch-year) (leap-years (dec utc-year))) - year-days-so-far (|> (i/* 365 years-since-epoch) + year-days-so-far (|> (i/* +365 years-since-epoch) (i/+ previous-leap-days)) month-days-so-far (|> months row.to-list (list.take (.nat (dec utc-month))) - (list/fold n/+ +0)) + (list/fold n/+ 0)) total-days (|> year-days-so-far (i/+ (.int month-days-so-far)) (i/+ (dec utc-day)))]] @@ -320,18 +320,18 @@ (let [[[year month day] _] (extract-date instant)] {#date.year year #date.month (case (dec month) - 0 #date.January - 1 #date.February - 2 #date.March - 3 #date.April - 4 #date.May - 5 #date.June - 6 #date.July - 7 #date.August - 8 #date.September - 9 #date.October - 10 #date.November - 11 #date.December + +0 #date.January + +1 #date.February + +2 #date.March + +3 #date.April + +4 #date.May + +5 #date.June + +6 #date.July + +7 #date.August + +8 #date.September + +9 #date.October + +10 #date.November + +11 #date.December _ (undefined)) #date.day (.nat day)})) @@ -350,16 +350,16 @@ (dec days) days) ## 1970/01/01 was a Thursday - y1970m0d0 4] + y1970m0d0 +4] (case (|> y1970m0d0 - (i/+ days) (i/% 7) + (i/+ days) (i/% +7) ## This is done to turn negative days into positive days. - (i/+ 7) (i/% 7)) - 0 #date.Sunday - 1 #date.Monday - 2 #date.Tuesday - 3 #date.Wednesday - 4 #date.Thursday - 5 #date.Friday - 6 #date.Saturday + (i/+ +7) (i/% +7)) + +0 #date.Sunday + +1 #date.Monday + +2 #date.Tuesday + +3 #date.Wednesday + +4 #date.Thursday + +5 #date.Friday + +6 #date.Saturday _ (undefined)))) diff --git a/stdlib/source/lux/type.lux b/stdlib/source/lux/type.lux index 376d40d67..5dd1e905f 100644 --- a/stdlib/source/lux/type.lux +++ b/stdlib/source/lux/type.lux @@ -93,7 +93,7 @@ (do-template [<name> <tag>] [(def: #export (<name> type) (-> Type [Nat Type]) - (loop [num-args +0 + (loop [num-args 0 type type] (case type (<tag> env sub-type) @@ -305,7 +305,7 @@ [(def: #export (<name> size body) (-> Nat Type Type) (case size - +0 body + 0 body _ (|> body (<name> (dec size)) (<tag> (list)))))] [univ-q #.UnivQ] @@ -333,7 +333,7 @@ (def: #export (array level elem-type) (-> Nat Type Type) (case level - +0 elem-type + 0 elem-type _ (|> elem-type (array (dec level)) (list) (#.Primitive "#Array")))) (syntax: #export (:log! {input (p.or s.identifier diff --git a/stdlib/source/lux/type/check.lux b/stdlib/source/lux/type/check.lux index 7e77b0bb6..ce5ce652a 100644 --- a/stdlib/source/lux/type/check.lux +++ b/stdlib/source/lux/type/check.lux @@ -298,8 +298,8 @@ (def: #export fresh-context Type-Context - {#.var-counter +0 - #.ex-counter +0 + {#.var-counter 0 + #.ex-counter 0 #.var-bindings (list) }) @@ -357,7 +357,7 @@ then) (do Monad<Check> [ring (ring id) - _ (assert "" (n/> +1 (set.size ring))) + _ (assert "" (n/> 1 (set.size ring))) _ (monad.map @ (update type) (set.to-list ring))] then) (do Monad<Check> diff --git a/stdlib/source/lux/type/implicit.lux b/stdlib/source/lux/type/implicit.lux index 91de1058e..6f26a01f8 100644 --- a/stdlib/source/lux/type/implicit.lux +++ b/stdlib/source/lux/type/implicit.lux @@ -65,12 +65,12 @@ (find-member-type idx sig-type')) (#.Product left right) - (if (n/= +0 idx) + (if (n/= 0 idx) (:: check.Monad<Check> wrap left) (find-member-type (dec idx) right)) _ - (if (n/= +0 idx) + (if (n/= 0 idx) (:: check.Monad<Check> wrap sig-type) (check.fail (format "Cannot find member type " (%n idx) " for " (%type sig-type)))))) @@ -326,10 +326,10 @@ (::: eq.= x y) "(List Nat) equivalence" (::: = - (list.n/range +1 +10) - (list.n/range +1 +10)) + (list.n/range 1 10) + (list.n/range 1 10)) "(Functor List) map" - (::: map 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/resource.lux b/stdlib/source/lux/type/resource.lux index 68d0410dd..d3f7b7ab0 100644 --- a/stdlib/source/lux/type/resource.lux +++ b/stdlib/source/lux/type/resource.lux @@ -185,7 +185,7 @@ (do p.Monad<Parser> [raw s.nat _ (p.assert (ex.construct amount-cannot-be-zero []) - (n/> +0 raw))] + (n/> 0 raw))] (wrap raw))) (do-template [<name> <m> <monad> <from> <to>] diff --git a/stdlib/source/lux/type/unit.lux b/stdlib/source/lux/type/unit.lux index df714a996..96584a989 100644 --- a/stdlib/source/lux/type/unit.lux +++ b/stdlib/source/lux/type/unit.lux @@ -85,10 +85,10 @@ (s.tuple (do p.Monad<Parser> [numerator s.int _ (p.assert (format "Numerator must be positive: " (%i numerator)) - (i/> 0 numerator)) + (i/> +0 numerator)) denominator s.int _ (p.assert (format "Denominator must be positive: " (%i denominator)) - (i/> 0 denominator))] + (i/> +0 denominator))] (wrap [(.nat numerator) (.nat denominator)])))) (syntax: #export (scale: @@ -150,13 +150,13 @@ (i// (.int denominator)) in))) -(scale: #export Kilo [1 1_000]) -(scale: #export Mega [1 1_000_000]) -(scale: #export Giga [1 1_000_000_000]) +(scale: #export Kilo [+1 +1_000]) +(scale: #export Mega [+1 +1_000_000]) +(scale: #export Giga [+1 +1_000_000_000]) -(scale: #export Milli [ 1_000 1]) -(scale: #export Micro [ 1_000_000 1]) -(scale: #export Nano [1_000_000_000 1]) +(scale: #export Milli [ +1_000 +1]) +(scale: #export Micro [ +1_000_000 +1]) +(scale: #export Nano [+1_000_000_000 +1]) (unit: #export Gram) (unit: #export Meter) diff --git a/stdlib/source/lux/world/binary.lux b/stdlib/source/lux/world/binary.lux index d89b7ae3a..a125b8067 100644 --- a/stdlib/source/lux/world/binary.lux +++ b/stdlib/source/lux/world/binary.lux @@ -30,7 +30,7 @@ (def: byte-mask I64 - (|> +1 (i64.left-shift +8) dec .i64)) + (|> 1 (i64.left-shift 8) dec .i64)) (def: i64 (-> (primitive "java.lang.Byte") I64) @@ -52,34 +52,34 @@ (def: #export (read/16 idx binary) (-> Nat Binary (Error I64)) - (if (n/< (host.array-length binary) (n/+ +1 idx)) + (if (n/< (host.array-length binary) (n/+ 1 idx)) (#error.Success ($_ i64.or - (i64.left-shift +8 (..i64 (host.array-read idx binary))) - (..i64 (host.array-read (n/+ +1 idx) binary)))) + (i64.left-shift 8 (..i64 (host.array-read idx binary))) + (..i64 (host.array-read (n/+ 1 idx) binary)))) (ex.throw index-out-of-bounds (%n idx)))) (def: #export (read/32 idx binary) (-> Nat Binary (Error I64)) - (if (n/< (host.array-length binary) (n/+ +3 idx)) + (if (n/< (host.array-length binary) (n/+ 3 idx)) (#error.Success ($_ i64.or - (i64.left-shift +24 (..i64 (host.array-read idx binary))) - (i64.left-shift +16 (..i64 (host.array-read (n/+ +1 idx) binary))) - (i64.left-shift +8 (..i64 (host.array-read (n/+ +2 idx) binary))) - (..i64 (host.array-read (n/+ +3 idx) binary)))) + (i64.left-shift 24 (..i64 (host.array-read idx binary))) + (i64.left-shift 16 (..i64 (host.array-read (n/+ 1 idx) binary))) + (i64.left-shift 8 (..i64 (host.array-read (n/+ 2 idx) binary))) + (..i64 (host.array-read (n/+ 3 idx) binary)))) (ex.throw index-out-of-bounds (%n idx)))) (def: #export (read/64 idx binary) (-> Nat Binary (Error I64)) - (if (n/< (host.array-length binary) (n/+ +7 idx)) + (if (n/< (host.array-length binary) (n/+ 7 idx)) (#error.Success ($_ i64.or - (i64.left-shift +56 (..i64 (host.array-read idx binary))) - (i64.left-shift +48 (..i64 (host.array-read (n/+ +1 idx) binary))) - (i64.left-shift +40 (..i64 (host.array-read (n/+ +2 idx) binary))) - (i64.left-shift +32 (..i64 (host.array-read (n/+ +3 idx) binary))) - (i64.left-shift +24 (..i64 (host.array-read (n/+ +4 idx) binary))) - (i64.left-shift +16 (..i64 (host.array-read (n/+ +5 idx) binary))) - (i64.left-shift +8 (..i64 (host.array-read (n/+ +6 idx) binary))) - (..i64 (host.array-read (n/+ +7 idx) binary)))) + (i64.left-shift 56 (..i64 (host.array-read idx binary))) + (i64.left-shift 48 (..i64 (host.array-read (n/+ 1 idx) binary))) + (i64.left-shift 40 (..i64 (host.array-read (n/+ 2 idx) binary))) + (i64.left-shift 32 (..i64 (host.array-read (n/+ 3 idx) binary))) + (i64.left-shift 24 (..i64 (host.array-read (n/+ 4 idx) binary))) + (i64.left-shift 16 (..i64 (host.array-read (n/+ 5 idx) binary))) + (i64.left-shift 8 (..i64 (host.array-read (n/+ 6 idx) binary))) + (..i64 (host.array-read (n/+ 7 idx) binary)))) (ex.throw index-out-of-bounds (%n idx)))) (def: #export (write/8 idx value binary) @@ -92,36 +92,36 @@ (def: #export (write/16 idx value binary) (-> Nat (I64 Any) Binary (Error Binary)) - (if (n/< (host.array-length binary) (n/+ +1 idx)) + (if (n/< (host.array-length binary) (n/+ 1 idx)) (exec (|> binary - (host.array-write idx (..byte (i64.logical-right-shift +8 value))) - (host.array-write (n/+ +1 idx) (..byte value))) + (host.array-write idx (..byte (i64.logical-right-shift 8 value))) + (host.array-write (n/+ 1 idx) (..byte value))) (#error.Success binary)) (ex.throw index-out-of-bounds (%n idx)))) (def: #export (write/32 idx value binary) (-> Nat (I64 Any) Binary (Error Binary)) - (if (n/< (host.array-length binary) (n/+ +3 idx)) + (if (n/< (host.array-length binary) (n/+ 3 idx)) (exec (|> binary - (host.array-write idx (..byte (i64.logical-right-shift +24 value))) - (host.array-write (n/+ +1 idx) (..byte (i64.logical-right-shift +16 value))) - (host.array-write (n/+ +2 idx) (..byte (i64.logical-right-shift +8 value))) - (host.array-write (n/+ +3 idx) (..byte value))) + (host.array-write idx (..byte (i64.logical-right-shift 24 value))) + (host.array-write (n/+ 1 idx) (..byte (i64.logical-right-shift 16 value))) + (host.array-write (n/+ 2 idx) (..byte (i64.logical-right-shift 8 value))) + (host.array-write (n/+ 3 idx) (..byte value))) (#error.Success binary)) (ex.throw index-out-of-bounds (%n idx)))) (def: #export (write/64 idx value binary) (-> Nat (I64 Any) Binary (Error Binary)) - (if (n/< (host.array-length binary) (n/+ +7 idx)) + (if (n/< (host.array-length binary) (n/+ 7 idx)) (exec (|> binary - (host.array-write idx (..byte (i64.logical-right-shift +56 value))) - (host.array-write (n/+ +1 idx) (..byte (i64.logical-right-shift +48 value))) - (host.array-write (n/+ +2 idx) (..byte (i64.logical-right-shift +40 value))) - (host.array-write (n/+ +3 idx) (..byte (i64.logical-right-shift +32 value))) - (host.array-write (n/+ +4 idx) (..byte (i64.logical-right-shift +24 value))) - (host.array-write (n/+ +5 idx) (..byte (i64.logical-right-shift +16 value))) - (host.array-write (n/+ +6 idx) (..byte (i64.logical-right-shift +8 value))) - (host.array-write (n/+ +7 idx) (..byte value))) + (host.array-write idx (..byte (i64.logical-right-shift 56 value))) + (host.array-write (n/+ 1 idx) (..byte (i64.logical-right-shift 48 value))) + (host.array-write (n/+ 2 idx) (..byte (i64.logical-right-shift 40 value))) + (host.array-write (n/+ 3 idx) (..byte (i64.logical-right-shift 32 value))) + (host.array-write (n/+ 4 idx) (..byte (i64.logical-right-shift 24 value))) + (host.array-write (n/+ 5 idx) (..byte (i64.logical-right-shift 16 value))) + (host.array-write (n/+ 6 idx) (..byte (i64.logical-right-shift 8 value))) + (host.array-write (n/+ 7 idx) (..byte value))) (#error.Success binary)) (ex.throw index-out-of-bounds (%n idx)))) diff --git a/stdlib/source/lux/world/net/udp.jvm.lux b/stdlib/source/lux/world/net/udp.jvm.lux index 6974af0ba..e8eeb1b1b 100644 --- a/stdlib/source/lux/world/net/udp.jvm.lux +++ b/stdlib/source/lux/world/net/udp.jvm.lux @@ -58,8 +58,8 @@ [addresses (InetAddress::getAllByName [address])] (: (io.IO (e.Error InetAddress)) (case (array.size addresses) - +0 (io.io (ex.throw cannot-resolve-address address)) - +1 (wrap (maybe.assume (array.read +0 addresses))) + 0 (io.io (ex.throw cannot-resolve-address address)) + 1 (wrap (maybe.assume (array.read 0 addresses))) _ (io.io (ex.throw multiple-candidate-addresses address)))))) (abstract: #export UDP {} diff --git a/stdlib/test/test/lux.lux b/stdlib/test/test/lux.lux index 65f176b87..61a0299ea 100644 --- a/stdlib/test/test/lux.lux +++ b/stdlib/test/test/lux.lux @@ -15,9 +15,9 @@ test]) (context: "Value identity." - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) + [size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 10)))) x (r.unicode size) y (r.unicode size)] ($_ seq @@ -31,14 +31,14 @@ (do-template [category rand-gen even? odd? = < >] [(context: (format "[" category "] " "Simple operations.") - (<| (times +100) + (<| (times 100) (do @ [value rand-gen] ($_ seq (test (format "[" category "] " "Moving up-down or down-up should result in same value.") (and (|> value inc dec (= value)) (|> value dec inc (= value)))) - (test (format "[" category "] " "(x+1) > x && (x-1) < x") + (test (format "[" category "] " "(x1) > x && (x-1) < x") (and (|> value inc (> value)) (|> value dec (< value)))) (test (format "[" category "] " "Every odd/even number is surrounded by two of the other kind.") @@ -54,7 +54,7 @@ (do-template [category rand-gen = < > <= >= min max] [(context: (format "[" category "] " "(More) simple operations.") - (<| (times +100) + (<| (times 100) (do @ [x rand-gen y rand-gen] @@ -77,7 +77,7 @@ (do-template [category rand-gen = + - * / <%> > <0> <1> <factor> <cap> <prep>] [(context: (format "[" category "] " "Additive identity") - (<| (times +100) + (<| (times 100) (do @ [x rand-gen] (test "" @@ -85,7 +85,7 @@ (|> x (- <0>) (= x))))))) (context: (format "[" category "] " "Addition & Substraction") - (<| (times +100) + (<| (times 100) (do @ [x (:: @ map <prep> rand-gen) y (:: @ map <prep> rand-gen) @@ -96,7 +96,7 @@ (|> x (+ y) (- y) (= x))))))) (context: (format "[" category "] " "Multiplicative identity") - (<| (times +100) + (<| (times 100) (do @ [x rand-gen] (test "" @@ -108,7 +108,7 @@ (|> x (/ <1>) (= x)))))))) (context: (format "[" category "] " "Multiplication & Division") - (<| (times +100) + (<| (times 100) (do @ [x (:: @ map <cap> rand-gen) y (|> rand-gen @@ -125,29 +125,29 @@ (|> x' (/ y) (* y) (= x')))) ))))] - ["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] + ["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] ["Rev" r.rev r/= r/+ r/- r/* r// r/% r/> .0 (.rev -1) (.rev -1) id id] ) (def: frac-rev (r.Random Rev) (|> r.rev - (:: r.Functor<Random> map (|>> (i64.left-shift +11) (i64.logical-right-shift +11))))) + (:: r.Functor<Random> map (|>> (i64.left-shift 11) (i64.logical-right-shift 11))))) (do-template [category rand-gen -> <- = <cap>] [(context: (format "[" category "] " "Numeric conversions") - (<| (times +100) + (<| (times 100) (do @ [value rand-gen #let [value (<cap> value)]] (test "" (|> value -> <- (= value))))))] - ["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)] + ["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] ["Rev->Frac" frac-rev rev-to-frac frac-to-rev r/= id] ) @@ -155,23 +155,23 @@ (context: "Simple macros and constructs" ($_ seq (test "Can write easy loops for iterative programming." - (i/= 1000 - (loop [counter 0 - value 1] - (if (i/< 3 counter) - (recur (inc counter) (i/* 10 value)) + (i/= +1000 + (loop [counter +0 + value +1] + (if (i/< +3 counter) + (recur (inc counter) (i/* +10 value)) value)))) (test "Can create lists easily through macros." - (and (case (list 1 2 3) - (#.Cons 1 (#.Cons 2 (#.Cons 3 #.Nil))) + (and (case (list +1 +2 +3) + (#.Cons +1 (#.Cons +2 (#.Cons +3 #.Nil))) #1 _ #0) - (case (list& 1 2 3 (list 4 5 6)) - (#.Cons 1 (#.Cons 2 (#.Cons 3 (#.Cons 4 (#.Cons 5 (#.Cons 6 #.Nil)))))) + (case (list& +1 +2 +3 (list +4 +5 +6)) + (#.Cons +1 (#.Cons +2 (#.Cons +3 (#.Cons +4 (#.Cons +5 (#.Cons +6 #.Nil)))))) #1 _ @@ -189,7 +189,7 @@ (i/+ (i/* x x) (i/* y y))) (context: "Templates." - (<| (times +100) + (<| (times 100) (do @ [x r.int y r.int] diff --git a/stdlib/test/test/lux/cli.lux b/stdlib/test/test/lux/cli.lux index 6d156d3b2..501c62df4 100644 --- a/stdlib/test/test/lux/cli.lux +++ b/stdlib/test/test/lux/cli.lux @@ -17,16 +17,16 @@ lux/test) (context: "CLI" - (<| (times +100) + (<| (times 100) (do @ - [num-args (|> r.nat (:: @ map (n/% +10))) + [num-args (|> r.nat (:: @ map (n/% 10))) #let [(^open "Nat/.") number.Codec<Text,Nat> gen-arg (:: @ map Nat/encode r.nat)] yes gen-arg - #let [gen-ignore (|> (r.unicode +5) (r.filter (|>> (text/= yes) not)))] + #let [gen-ignore (|> (r.unicode 5) (r.filter (|>> (text/= yes) not)))] no gen-ignore - pre-ignore (r.list +5 gen-ignore) - post-ignore (r.list +5 gen-ignore)] + pre-ignore (r.list 5 gen-ignore) + post-ignore (r.list 5 gen-ignore)] ($_ seq (test "Can read any argument." (|> (/.run (list yes) /.any) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/case.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/case.lux index fd516d048..abe199241 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/case.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/case.lux @@ -67,7 +67,7 @@ [#.Int r.int code.int] [#.Rev r.rev code.rev] [#.Frac r.frac code.frac] - [#.Text (r.unicode +5) code.text]) + [#.Text (r.unicode 5) code.text]) (^ [_ (#.Tuple (list))]) (random/wrap (list (' []))) @@ -118,7 +118,7 @@ choiceC (maybe.assume (list.nth choice primitivesC))]] (wrap (` ((~ choiceT) (~ choiceC))))) (do r.Monad<Random> - [size (|> r.nat (:: @ map (n/% +3))) + [size (|> r.nat (:: @ map (n/% 3))) elems (r.list size input)] (wrap (code.tuple elems))) (random/wrap (code.record (list.zip2 record-tags primitivesC))) @@ -129,17 +129,17 @@ [pattern body]) (context: "Pattern-matching." - ## #seed +9253409297339902486 - ## #seed +3793366152923578600 - (<| (seed +5004137551292836565) - ## (times +100) + ## #seed 9253409297339902486 + ## #seed 3793366152923578600 + (<| (seed 5004137551292836565) + ## (times 100) (do @ - [module-name (r.unicode +5) - variant-name (r.unicode +5) - record-name (|> (r.unicode +5) (r.filter (|>> (text/= variant-name) not))) - size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) - variant-tags (|> (r.set text.Hash<Text> size (r.unicode +5)) (:: @ map set.to-list)) - record-tags (|> (r.set text.Hash<Text> size (r.unicode +5)) (:: @ map set.to-list)) + [module-name (r.unicode 5) + variant-name (r.unicode 5) + record-name (|> (r.unicode 5) (r.filter (|>> (text/= variant-name) not))) + size (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) + variant-tags (|> (r.set text.Hash<Text> size (r.unicode 5)) (:: @ map set.to-list)) + record-tags (|> (r.set text.Hash<Text> size (r.unicode 5)) (:: @ map set.to-list)) primitivesTC (r.list size _primitive.primitive) #let [primitivesT (list/map product.left primitivesTC) primitivesC (list/map product.right primitivesTC) @@ -178,7 +178,7 @@ _ (module.declare-tags record-tags #0 (#.Named [module-name record-name] (type.tuple primitivesT)))]) - (module.with-module +0 module-name))]] + (module.with-module 0 module-name))]] ($_ seq (test "Will reject empty pattern-matching (no branches)." (|> (analyse-pm (list)) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/function.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/function.lux index 66c5f1a23..ba84d926f 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/function.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/function.lux @@ -47,10 +47,10 @@ #0))) (context: "Function definition." - (<| (times +100) + (<| (times 100) (do @ - [func-name (r.unicode +5) - arg-name (|> (r.unicode +5) (r.filter (|>> (text/= func-name) not))) + [func-name (r.unicode 5) + arg-name (|> (r.unicode 5) (r.filter (|>> (text/= func-name) not))) [outputT outputC] _primitive.primitive [inputT _] _primitive.primitive #let [g!arg (code.local-identifier arg-name)]] @@ -76,19 +76,19 @@ )))) (context: "Function application." - (<| (times +100) + (<| (times 100) (do @ - [full-args (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + [full-args (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) partial-args (|> r.nat (:: @ map (n/% full-args))) - var-idx (|> r.nat (:: @ map (|>> (n/% full-args) (n/max +1)))) + var-idx (|> r.nat (:: @ map (|>> (n/% full-args) (n/max 1)))) inputsTC (r.list full-args _primitive.primitive) #let [inputsT (list/map product.left inputsTC) inputsC (list/map product.right inputsTC)] [outputT outputC] _primitive.primitive #let [funcT (type.function inputsT outputT) partialT (type.function (list.drop partial-args inputsT) outputT) - varT (#.Parameter +1) - polyT (<| (type.univ-q +1) + varT (#.Parameter 1) + polyT (<| (type.univ-q 1) (type.function (list.concat (list (list.take var-idx inputsT) (list varT) (list.drop (inc var-idx) inputsT)))) @@ -97,10 +97,10 @@ partial-poly-inputsT (list.drop (inc var-idx) inputsT) partial-polyT1 (<| (type.function partial-poly-inputsT) poly-inputT) - partial-polyT2 (<| (type.univ-q +1) + partial-polyT2 (<| (type.univ-q 1) (type.function (#.Cons varT partial-poly-inputsT)) varT) - dummy-function (#analysis.Function (list) (#analysis.Reference (reference.local +1)))]] + dummy-function (#analysis.Function (list) (#analysis.Reference (reference.local 1)))]] ($_ seq (test "Can analyse monomorphic type application." (|> (/.apply ..analyse funcT dummy-function inputsC) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/primitive.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/primitive.lux index 9a5595f22..1d807e519 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/primitive.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/primitive.lux @@ -36,13 +36,13 @@ (~~ (do-template [<type> <code-wrapper> <value-gen>] [(r.and (random/wrap <type>) (random/map <code-wrapper> <value-gen>))] - [Any code.tuple (r.list +0 ..unit)] + [Any code.tuple (r.list 0 ..unit)] [Bit code.bit r.bit] [Nat code.nat r.nat] [Int code.int r.int] [Rev code.rev r.rev] [Frac code.frac r.frac] - [Text code.text (r.unicode +5)] + [Text code.text (r.unicode 5)] ))))) (exception: (wrong-inference {expected Type} {inferred Type}) @@ -71,7 +71,7 @@ _ #0))) - (<| (times +100) + (<| (times 100) (`` ($_ seq (~~ (do-template [<desc> <type> <tag> <random> <constructor>] [(do @ @@ -89,5 +89,5 @@ ["int" Int #analysis.Int r.int code.int] ["rev" Rev #analysis.Rev r.rev code.rev] ["frac" Frac #analysis.Frac r.frac code.frac] - ["text" Text #analysis.Text (r.unicode +5) code.text] + ["text" Text #analysis.Text (r.unicode 5) code.text] ))))))) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/procedure/common.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/procedure/common.lux index 5c7296eff..5fc04278b 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/procedure/common.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/procedure/common.lux @@ -47,7 +47,7 @@ ) (context: "Lux procedures" - (<| (times +100) + (<| (times 100) (do @ [[primT primC] _primitive.primitive [antiT antiC] (|> _primitive.primitive @@ -64,7 +64,7 @@ )))) (context: "Bit procedures" - (<| (times +100) + (<| (times 100) (do @ [subjectC (|> r.nat (:: @ map code.nat)) signedC (|> r.int (:: @ map code.int)) @@ -85,7 +85,7 @@ )))) (context: "Int procedures" - (<| (times +100) + (<| (times 100) (do @ [subjectC (|> r.int (:: @ map code.int)) paramC (|> r.int (:: @ map code.int))] @@ -111,11 +111,11 @@ )))) (context: "Frac procedures" - (<| (times +100) + (<| (times 100) (do @ [subjectC (|> r.frac (:: @ map code.frac)) paramC (|> r.frac (:: @ map code.frac)) - encodedC (|> (r.unicode +5) (:: @ map code.text))] + encodedC (|> (r.unicode 5) (:: @ map code.text))] ($_ seq (test "Can add frac numbers." (check-success+ "lux frac +" (list subjectC paramC) Frac)) @@ -146,11 +146,11 @@ )))) (context: "Text procedures" - (<| (times +100) + (<| (times 100) (do @ - [subjectC (|> (r.unicode +5) (:: @ map code.text)) - paramC (|> (r.unicode +5) (:: @ map code.text)) - replacementC (|> (r.unicode +5) (:: @ map code.text)) + [subjectC (|> (r.unicode 5) (:: @ map code.text)) + paramC (|> (r.unicode 5) (:: @ map code.text)) + replacementC (|> (r.unicode 5) (:: @ map code.text)) fromC (|> r.nat (:: @ map code.nat)) toC (|> r.nat (:: @ map code.nat))] ($_ seq @@ -171,12 +171,12 @@ )))) (context: "Array procedures" - (<| (times +100) + (<| (times 100) (do @ [[elemT elemC] _primitive.primitive sizeC (|> r.nat (:: @ map code.nat)) idxC (|> r.nat (:: @ map code.nat)) - var-name (r.unicode +5) + var-name (r.unicode 5) #let [arrayT (type (Array elemT)) g!array (code.local-identifier var-name) array-operation (function (_ output-type code) @@ -208,7 +208,7 @@ )))) (context: "Math procedures" - (<| (times +100) + (<| (times 100) (do @ [subjectC (|> r.frac (:: @ map code.frac)) paramC (|> r.frac (:: @ map code.frac))] @@ -239,12 +239,12 @@ ["lux math pow" "power"]))))))) (context: "Atom procedures" - (<| (times +100) + (<| (times 100) (do @ [[elemT elemC] _primitive.primitive sizeC (|> r.nat (:: @ map code.nat)) idxC (|> r.nat (:: @ map code.nat)) - var-name (r.unicode +5) + var-name (r.unicode 5) #let [atomT (type (atom.Atom elemT))]] ($_ seq (test "Can create atomic reference." @@ -277,7 +277,7 @@ )))) (context: "Process procedures" - (<| (times +100) + (<| (times 100) (do @ [[primT primC] _primitive.primitive timeC (|> r.nat (:: @ map code.nat))] @@ -292,9 +292,9 @@ )))) (context: "IO procedures" - (<| (times +100) + (<| (times 100) (do @ - [logC (|> (r.unicode +5) (:: @ map code.text)) + [logC (|> (r.unicode 5) (:: @ map code.text)) exitC (|> r.int (:: @ map code.int))] ($_ seq (test "Can log messages to standard output." diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux index 5c5ac9ee5..dae6d916b 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux @@ -48,13 +48,13 @@ (def: (reach-test var-name [export? def-module] [import? dependent-module] check!) (-> Text [Bit Text] [Bit Text] Check Bit) (|> (do phase.Monad<Operation> - [_ (module.with-module +0 def-module + [_ (module.with-module 0 def-module (module.define var-name [Any (if export? (' {#.export? #1}) (' {})) []]))] - (module.with-module +0 dependent-module + (module.with-module 0 dependent-module (do @ [_ (if import? (module.import def-module) @@ -65,13 +65,13 @@ check!)) (context: "References" - (<| (times +100) + (<| (times 100) (do @ [[expectedT _] _primitive.primitive - def-module (r.unicode +5) - scope-name (r.unicode +5) - var-name (r.unicode +5) - dependent-module (|> (r.unicode +5) + def-module (r.unicode 5) + scope-name (r.unicode 5) + var-name (r.unicode 5) + dependent-module (|> (r.unicode 5) (r.filter (|>> (text/= def-module) not)))] ($_ seq (test "Can analyse variable." @@ -82,7 +82,7 @@ (phase.run [analysisE.bundle (init.compiler [])]) (case> (^ (#e.Success [inferredT (#analysis.Reference (reference.local var))])) (and (type/= expectedT inferredT) - (n/= +0 var)) + (n/= 0 var)) _ #0))) @@ -92,7 +92,7 @@ [_ (module.define var-name [expectedT (' {}) []])] (typeA.with-inference (..analyse (code.identifier def-name)))) - (module.with-module +0 def-module) + (module.with-module 0 def-module) (phase.run [analysisE.bundle (init.compiler [])]) (case> (^ (#e.Success [_ inferredT (#analysis.Reference (reference.constant constant-name))])) (and (type/= expectedT inferredT) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/structure.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/structure.lux index eb517be72..d36bffe20 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/structure.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/structure.lux @@ -75,7 +75,7 @@ (All [a] (-> Text (List module.Tag) Type (Operation a) (Operation [Module a]))) (|>> (do phase.Monad<Operation> [_ (module.declare-tags tags #0 type)]) - (module.with-module +0 module))) + (module.with-module 0 module))) (def: (check-variant module tags type size tag analysis) (-> Text (List module.Tag) Type Nat Tag (Operation Analysis) Bit) @@ -108,9 +108,9 @@ #0))) (context: "Sums" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + [size (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) choice (|> r.nat (:: @ map (n/% size))) primitives (r.list size _primitive.primitive) +choice (|> r.nat (:: @ map (n/% (inc size)))) @@ -119,7 +119,7 @@ [valueT valueC] (maybe.assume (list.nth choice primitives)) +size (inc size) +primitives (list.concat (list (list.take choice primitives) - (list [(#.Parameter +1) +valueC]) + (list [(#.Parameter 1) +valueC]) (list.drop choice primitives))) [+valueT +valueC] (maybe.assume (list.nth +choice +primitives)) +variantT (type.variant (list/map product.left +primitives))]] @@ -149,29 +149,29 @@ (/.sum ..analyse choice valueC))) check-fails)) (test "Can analyse sum through existential quantification." - (|> (typeA.with-type (type.ex-q +1 +variantT) + (|> (typeA.with-type (type.ex-q 1 +variantT) (/.sum ..analyse +choice +valueC)) check-succeeds)) (test "Can analyse sum through universal quantification." (let [check-outcome (if (not (n/= choice +choice)) check-succeeds check-fails)] - (|> (typeA.with-type (type.univ-q +1 +variantT) + (|> (typeA.with-type (type.univ-q 1 +variantT) (/.sum ..analyse +choice +valueC)) check-outcome))) )))) (context: "Products" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + [size (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) primitives (r.list size _primitive.primitive) choice (|> r.nat (:: @ map (n/% size))) [_ +valueC] _primitive.primitive #let [tupleT (type.tuple (list/map product.left primitives)) [singletonT singletonC] (|> primitives (list.nth choice) maybe.assume) +primitives (list.concat (list (list.take choice primitives) - (list [(#.Parameter +1) +valueC]) + (list [(#.Parameter 1) +valueC]) (list.drop choice primitives))) +tupleT (type.tuple (list/map product.left +primitives))]] ($_ seq @@ -212,26 +212,26 @@ _ #0))) (test "Can analyse product through existential quantification." - (|> (typeA.with-type (type.ex-q +1 +tupleT) + (|> (typeA.with-type (type.ex-q 1 +tupleT) (/.product ..analyse (list/map product.right +primitives))) check-succeeds)) (test "Cannot analyse product through universal quantification." - (|> (typeA.with-type (type.univ-q +1 +tupleT) + (|> (typeA.with-type (type.univ-q 1 +tupleT) (/.product ..analyse (list/map product.right +primitives))) check-fails)) )))) (context: "Tagged Sums" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) - tags (|> (r.set text.Hash<Text> size (r.unicode +5)) (:: @ map set.to-list)) + [size (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) + tags (|> (r.set text.Hash<Text> size (r.unicode 5)) (:: @ map set.to-list)) choice (|> r.nat (:: @ map (n/% size))) other-choice (|> r.nat (:: @ map (n/% size)) (r.filter (|>> (n/= choice) not))) primitives (r.list size _primitive.primitive) - module-name (r.unicode +5) - type-name (r.unicode +5) - #let [varT (#.Parameter +1) + module-name (r.unicode 5) + type-name (r.unicode 5) + #let [varT (#.Parameter 1) primitivesT (list/map product.left primitives) [choiceT choiceC] (maybe.assume (list.nth choice primitives)) [other-choiceT other-choiceC] (maybe.assume (list.nth other-choice primitives)) @@ -240,7 +240,7 @@ named-polyT (|> (type.variant (list.concat (list (list.take choice primitivesT) (list varT) (list.drop (inc choice) primitivesT)))) - (type.univ-q +1) + (type.univ-q 1) (#.Named [module-name type-name])) choice-tag (maybe.assume (list.nth choice tags)) other-choice-tag (maybe.assume (list.nth other-choice tags))]] @@ -261,15 +261,15 @@ )))) (context: "Records" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) - tags (|> (r.set text.Hash<Text> size (r.unicode +5)) (:: @ map set.to-list)) + [size (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) + tags (|> (r.set text.Hash<Text> size (r.unicode 5)) (:: @ map set.to-list)) primitives (r.list size _primitive.primitive) - module-name (r.unicode +5) - type-name (r.unicode +5) + module-name (r.unicode 5) + type-name (r.unicode 5) choice (|> r.nat (:: @ map (n/% size))) - #let [varT (#.Parameter +1) + #let [varT (#.Parameter 1) tagsC (list/map (|>> [module-name] code.tag) tags) primitivesT (list/map product.left primitives) primitivesC (list/map product.right primitives) @@ -279,7 +279,7 @@ named-polyT (|> (type.tuple (list.concat (list (list.take choice primitivesT) (list varT) (list.drop (inc choice) primitivesT)))) - (type.univ-q +1) + (type.univ-q 1) (#.Named [module-name type-name]))]] ($_ seq (test "Can infer record." diff --git a/stdlib/test/test/lux/compiler/default/phase/synthesis/case.lux b/stdlib/test/test/lux/compiler/default/phase/synthesis/case.lux index ad0d5c60a..f3c3b9d2e 100644 --- a/stdlib/test/test/lux/compiler/default/phase/synthesis/case.lux +++ b/stdlib/test/test/lux/compiler/default/phase/synthesis/case.lux @@ -20,10 +20,10 @@ ["." //primitive]) (context: "Dummy variables." - (<| (times +100) + (<| (times 100) (do @ [maskedA //primitive.primitive - temp (|> r.nat (:: @ map (n/% +100))) + temp (|> r.nat (:: @ map (n/% 100))) #let [maskA (analysis.control/case [maskedA [[(#analysis.Bind temp) @@ -37,7 +37,7 @@ (error.default #0)))))) (context: "Let expressions." - (<| (times +100) + (<| (times 100) (do @ [registerA r.nat inputA //primitive.primitive @@ -60,7 +60,7 @@ #0)))))) (context: "If expressions." - (<| (times +100) + (<| (times 100) (do @ [then|else r.bit inputA //primitive.primitive diff --git a/stdlib/test/test/lux/compiler/default/phase/synthesis/function.lux b/stdlib/test/test/lux/compiler/default/phase/synthesis/function.lux index 2249acca1..fae0e0fdf 100644 --- a/stdlib/test/test/lux/compiler/default/phase/synthesis/function.lux +++ b/stdlib/test/test/lux/compiler/default/phase/synthesis/function.lux @@ -42,7 +42,7 @@ predictionA])) (do @ [predictionA //primitive.primitive] - (wrap [+0 predictionA predictionA]))))))) + (wrap [0 predictionA predictionA]))))))) (def: (pick scope-size) (-> Nat (r.Random Nat)) @@ -51,12 +51,12 @@ (def: function-with-environment (r.Random [Arity Analysis Variable]) (do r.Monad<Random> - [num-locals (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) - #let [indices (list.n/range +0 (dec num-locals)) + [num-locals (|> r.nat (:: @ map (|>> (n/% 100) (n/max 10)))) + #let [indices (list.n/range 0 (dec num-locals)) local-env (list/map (|>> #reference.Local) indices) foreign-env (list/map (|>> #reference.Foreign) indices)] [arity bodyA predictionA] (: (r.Random [Arity Analysis Variable]) - (loop [arity +1 + (loop [arity 1 current-env foreign-env] (let [current-env/size (list.size current-env) resolver (list/fold (function (_ [idx var] resolver) @@ -68,7 +68,7 @@ [nest? r.bit] (if nest? (do @ - [num-picks (:: @ map (n/max +1) (pick (inc current-env/size))) + [num-picks (:: @ map (n/max 1) (pick (inc current-env/size))) picks (|> (r.set number.Hash<Nat> num-picks (pick current-env/size)) (:: @ map set.to-list)) [arity bodyA predictionA] (recur (inc arity) @@ -90,7 +90,7 @@ (def: local-function (r.Random [Arity Analysis Variable]) - (loop [arity +0 + (loop [arity 0 nest? #1] (if nest? (do r.Monad<Random> @@ -100,14 +100,14 @@ (#analysis.Function (list) bodyA) predictionA])) (do r.Monad<Random> - [chosen (|> r.nat (:: @ map (|>> (n/% +100) (n/max +2))))] + [chosen (|> r.nat (:: @ map (|>> (n/% 100) (n/max 2))))] (wrap [arity (#analysis.Reference (reference.local chosen)) (|> chosen (n/+ (dec arity)) #reference.Local)]))))) (context: "Function definition." - (<| (seed +13007429814532219492) - ## (times +100) + (<| (seed 13007429814532219492) + ## (times 100) (do @ [[arity//constant function//constant prediction//constant] constant-function [arity//environment function//environment prediction//environment] function-with-environment @@ -122,7 +122,7 @@ (//primitive.corresponds? prediction//constant output)) _ - (n/= +0 arity//constant)))) + (n/= 0 arity//constant)))) (test "Folded functions provide direct access to environment variables." (|> function//environment expression.synthesize @@ -146,9 +146,9 @@ )))) (context: "Function application." - (<| (times +100) + (<| (times 100) (do @ - [arity (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1)))) + [arity (|> r.nat (:: @ map (|>> (n/% 10) (n/max 1)))) funcA //primitive.primitive argsA (r.list arity //primitive.primitive)] ($_ seq diff --git a/stdlib/test/test/lux/compiler/default/phase/synthesis/primitive.lux b/stdlib/test/test/lux/compiler/default/phase/synthesis/primitive.lux index cdeeea22b..9587919a2 100644 --- a/stdlib/test/test/lux/compiler/default/phase/synthesis/primitive.lux +++ b/stdlib/test/test/lux/compiler/default/phase/synthesis/primitive.lux @@ -30,7 +30,7 @@ r.int r.rev r.frac - (r.unicode +5)))] + (r.unicode 5)))] (wrap (#analysis.Primitive primitive)))) (def: #export (corresponds? analysis synthesis) @@ -68,14 +68,14 @@ #0)) (context: "Primitives." - (<| (times +100) + (<| (times 100) (do @ [|bit| r.bit |nat| r.nat |int| r.int |rev| r.rev |frac| r.frac - |text| (r.unicode +5)] + |text| (r.unicode 5)] (`` ($_ seq (~~ (do-template [<desc> <analysis> <synthesis> <sample>] [(test (format "Can synthesize " <desc> ".") diff --git a/stdlib/test/test/lux/compiler/default/phase/synthesis/structure.lux b/stdlib/test/test/lux/compiler/default/phase/synthesis/structure.lux index 924a4126d..90fd155b0 100644 --- a/stdlib/test/test/lux/compiler/default/phase/synthesis/structure.lux +++ b/stdlib/test/test/lux/compiler/default/phase/synthesis/structure.lux @@ -23,9 +23,9 @@ ["." //primitive]) (context: "Variants" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +10) (n/+ +2)))) + [size (|> r.nat (:: @ map (|>> (n/% 10) (n/+ 2)))) tagA (|> r.nat (:: @ map (n/% size))) memberA //primitive.primitive] ($_ seq @@ -44,9 +44,9 @@ )))) (context: "Tuples" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + [size (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) membersA (r.list size //primitive.primitive)] ($_ seq (test "Can synthesize tuple." diff --git a/stdlib/test/test/lux/compiler/default/syntax.lux b/stdlib/test/test/lux/compiler/default/syntax.lux index 07befa13c..e52a6ea02 100644 --- a/stdlib/test/test/lux/compiler/default/syntax.lux +++ b/stdlib/test/test/lux/compiler/default/syntax.lux @@ -23,8 +23,8 @@ (def: default-cursor Cursor {#.module "" - #.line +0 - #.column +0}) + #.line 0 + #.column 0}) (def: name-part^ (r.Random Text) @@ -34,11 +34,11 @@ space "\t\v \n\r\f" invalid-range (format digits delimiters space) char-gen (|> r.nat - (:: @ map (|>> (n/% +256) (n/max +1))) + (:: @ map (|>> (n/% 256) (n/max 1))) (r.filter (function (_ sample) (not (text.contains? (text.from-code sample) invalid-range)))))] - size (|> r.nat (:: @ map (|>> (n/% +20) (n/max +1))))] + size (|> r.nat (:: @ map (|>> (n/% 20) (n/max 1))))] (r.text char-gen size))) (def: name^ @@ -57,7 +57,7 @@ textual^ (: (r.Random Code) ($_ r.either (do r.Monad<Random> - [size (|> r.nat (r/map (n/% +20)))] + [size (|> r.nat (r/map (n/% 20)))] (|> (r.unicode size) (r/map code.text))) (|> name^ (r/map code.identifier)) (|> name^ (r/map code.tag)))) @@ -68,28 +68,28 @@ (r.rec (function (_ code^) (let [multi^ (do r.Monad<Random> - [size (|> r.nat (r/map (n/% +3)))] + [size (|> r.nat (r/map (n/% 3)))] (r.list size code^)) composite^ (: (r.Random Code) ($_ r.either (|> multi^ (r/map code.form)) (|> multi^ (r/map code.tuple)) (do r.Monad<Random> - [size (|> r.nat (r/map (n/% +3)))] + [size (|> r.nat (r/map (n/% 3)))] (|> (r.list size (r.and code^ code^)) (r/map code.record)))))] (r.either simple^ composite^)))))) (context: "Lux code syntax." - (<| (times +100) + (<| (times 100) (do @ [sample code^ other code^] ($_ seq (test "Can parse Lux code." (case (&.read "" (dict.new text.Hash<Text>) - [default-cursor +0 (code.to-text sample)]) + [default-cursor 0 (code.to-text sample)]) (#e.Error error) #0 @@ -97,8 +97,8 @@ (:: code.Equivalence<Code> = parsed sample))) (test "Can parse Lux multiple code nodes." (case (&.read "" (dict.new text.Hash<Text>) - [default-cursor +0 (format (code.to-text sample) " " - (code.to-text other))]) + [default-cursor 0 (format (code.to-text sample) " " + (code.to-text other))]) (#e.Error error) #0 @@ -114,15 +114,15 @@ )))) (context: "Frac special syntax." - (<| (times +100) + (<| (times 100) (do @ - [numerator (|> r.nat (:: @ map (|>> (n/% +100) .int int-to-frac))) - denominator (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1) .int int-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.bit - #let [expected (|> numerator (f// denominator) (f/* (if signed? -1.0 1.0)))]] + #let [expected (|> numerator (f// denominator) (f/* (if signed? -1.0 +1.0)))]] (test "Can parse frac ratio syntax." (case (&.read "" (dict.new text.Hash<Text>) - [default-cursor +0 + [default-cursor 0 (format (if signed? "-" "") (%i (frac-to-int numerator)) "/" @@ -135,12 +135,12 @@ )))) (context: "Nat special syntax." - (<| (times +100) + (<| (times 100) (do @ - [expected (|> r.nat (:: @ map (n/% +1_000)))] + [expected (|> r.nat (:: @ map (n/% 1_000)))] (test "Can parse nat char syntax." (case (&.read "" (dict.new text.Hash<Text>) - [default-cursor +0 + [default-cursor 0 (format "#" (%t (text.from-code expected)) "")]) (#e.Success [_ [_ (#.Nat actual)]]) (n/= expected actual) @@ -157,7 +157,7 @@ (n/= (char "(") value) (n/= (char ")") value))))))] (do r.Monad<Random> - [size (|> r.nat (r/map (n/% +20)))] + [size (|> r.nat (r/map (n/% 20)))] (r.text char-gen size)))) (def: comment^ @@ -172,8 +172,8 @@ (wrap (format "#( " comment " )#"))))))) (context: "Multi-line text & comments." - (<| (seed +12137892244981970631) - ## (times +100) + (<| (seed 12137892244981970631) + ## (times 100) (do @ [#let [char-gen (|> r.nat (r.filter (function (_ value) (not (or (text.space? value) @@ -181,7 +181,7 @@ x char-gen y char-gen z char-gen - offset-size (|> r.nat (r/map (|>> (n/% +10) (n/max +1)))) + offset-size (|> r.nat (r/map (|>> (n/% 10) (n/max 1)))) #let [offset (text.join-with "" (list.repeat offset-size " "))] sample code^ comment comment^ @@ -192,7 +192,7 @@ (text.from-code y) "\n" (text.from-code z))] (case (&.read "" (dict.new text.Hash<Text>) - [default-cursor +0 + [default-cursor 0 (format "\"" bad-match "\"")]) (#e.Error error) #1 @@ -208,7 +208,7 @@ (text.from-code z))] (case (&.read "" (dict.new text.Hash<Text>) [(|> default-cursor (update@ #.column (n/+ (dec offset-size)))) - +0 + 0 (format "\"" good-input "\"")]) (#e.Error error) #0 @@ -219,7 +219,7 @@ (code.text good-output))))) (test "Can handle comments." (case (&.read "" (dict.new text.Hash<Text>) - [default-cursor +0 + [default-cursor 0 (format comment (code.to-text sample))]) (#e.Error error) #0 @@ -228,7 +228,7 @@ (:: code.Equivalence<Code> = parsed sample))) (test "Will reject unbalanced multi-line comments." (and (case (&.read "" (dict.new text.Hash<Text>) - [default-cursor +0 + [default-cursor 0 (format "#(" "#(" unbalanced-comment ")#" (code.to-text sample))]) (#e.Error error) @@ -237,7 +237,7 @@ (#e.Success [_ parsed]) #0) (case (&.read "" (dict.new text.Hash<Text>) - [default-cursor +0 + [default-cursor 0 (format "#(" unbalanced-comment ")#" ")#" (code.to-text sample))]) (#e.Error error) diff --git a/stdlib/test/test/lux/concurrency/actor.lux b/stdlib/test/test/lux/concurrency/actor.lux index a1e9ec549..a43845380 100644 --- a/stdlib/test/test/lux/concurrency/actor.lux +++ b/stdlib/test/test/lux/concurrency/actor.lux @@ -38,19 +38,19 @@ ($_ seq (test "Can check if an actor is alive." (io.run (do io.Monad<IO> - [counter (new@Counter +0)] + [counter (new@Counter 0)] (wrap (&.alive? counter))))) (test "Can poison actors." (io.run (do io.Monad<IO> - [counter (new@Counter +0) + [counter (new@Counter 0) poisoned? (&.poison counter)] (wrap (and poisoned? (not (&.alive? counter))))))) (test "Cannot poison an already dead actor." (io.run (do io.Monad<IO> - [counter (new@Counter +0) + [counter (new@Counter 0) first-time (&.poison counter) second-time (&.poison counter)] (wrap (and first-time @@ -58,13 +58,13 @@ (wrap (do P.Monad<Promise> [result (do T.Monad<Task> - [#let [counter (io.run (new@Counter +0))] - output-1 (count! +1 counter) - output-2 (count! +1 counter) - output-3 (count! +1 counter)] - (wrap (and (n/= +1 output-1) - (n/= +2 output-2) - (n/= +3 output-3))))] + [#let [counter (io.run (new@Counter 0))] + output-1 (count! 1 counter) + output-2 (count! 1 counter) + output-3 (count! 1 counter)] + (wrap (and (n/= 1 output-1) + (n/= 2 output-2) + (n/= 3 output-3))))] (assert "Can send messages to actors." (case result (#e.Success outcome) diff --git a/stdlib/test/test/lux/concurrency/atom.lux b/stdlib/test/test/lux/concurrency/atom.lux index 03895bdeb..a10edcae7 100644 --- a/stdlib/test/test/lux/concurrency/atom.lux +++ b/stdlib/test/test/lux/concurrency/atom.lux @@ -10,7 +10,7 @@ lux/test) (context: "Atoms" - (<| (times +100) + (<| (times 100) (do @ [value r.nat swap-value r.nat diff --git a/stdlib/test/test/lux/concurrency/frp.lux b/stdlib/test/test/lux/concurrency/frp.lux index c69ae6038..46db40889 100644 --- a/stdlib/test/test/lux/concurrency/frp.lux +++ b/stdlib/test/test/lux/concurrency/frp.lux @@ -35,14 +35,14 @@ (let [(^open "list/.") (list.Equivalence<List> number.Equivalence<Int>)] ($_ seq (wrap (do promise.Monad<Promise> - [#let [values (list 0 1 2 3 4 5)] + [#let [values (list +0 +1 +2 +3 +4 +5)] output (promise.future (do io.Monad<IO> [#let [input (: (Channel Int) (frp.channel []))] output (read! input) _ (write! values input)] (wrap output))) - _ (promise.wait +100) + _ (promise.wait 100) output (promise.future (atom.read output))] (assert "Can pipe one channel into another." (list/= values @@ -54,12 +54,12 @@ [#let [input (: (Channel Int) (frp.channel [])) elems (frp.filter i/even? input)] output (read! elems) - _ (write! (list 0 1 2 3 4 5) input)] + _ (write! (list +0 +1 +2 +3 +4 +5) input)] (wrap output))) - _ (promise.wait +100) + _ (promise.wait 100) output (promise.future (atom.read output))] (assert "Can filter a channel's elements." - (list/= (list 0 2 4) + (list/= (list +0 +2 +4) (list.reverse output))))) (wrap (do promise.Monad<Promise> @@ -69,13 +69,13 @@ right (: (Channel Int) (frp.channel []))] merged (frp.merge (list left right)) output (read! merged) - _ (write! (list 0 1 2 3 4 5) left) - _ (write! (list 0 -1 -2 -3 -4 -5) right)] + _ (write! (list +0 +1 +2 +3 +4 +5) left) + _ (write! (list +0 -1 -2 -3 -4 -5) right)] (wrap output))) - _ (promise.wait +100) + _ (promise.wait 100) output (promise.future (atom.read output))] (assert "Can merge channels." - (list/= (list 0 1 2 3 4 5 0 -1 -2 -3 -4 -5) + (list/= (list +0 +1 +2 +3 +4 +5 +0 -1 -2 -3 -4 -5) (list.reverse output))))) (wrap (do promise.Monad<Promise> @@ -84,12 +84,12 @@ [#let [inputs (: (Channel Int) (frp.channel [])) mapped (:: frp.Functor<Channel> map inc inputs)] output (read! mapped) - _ (write! (list 0 1 2 3 4 5) inputs)] + _ (write! (list +0 +1 +2 +3 +4 +5) inputs)] (wrap output))) - _ (promise.wait +100) + _ (promise.wait 100) output (promise.future (atom.read output))] (assert "Functor goes over every element in a channel." - (list/= (list 1 2 3 4 5 6) + (list/= (list +1 +2 +3 +4 +5 +6) (list.reverse output))))) (wrap (do promise.Monad<Promise> @@ -100,23 +100,23 @@ output (read! (let [(^open ".") frp.Apply<Channel>] (apply >f< >a<))) _ (write! (list inc) >f<) - _ (write! (list 12345) >a<)] + _ (write! (list +12345) >a<)] (wrap output))) - _ (promise.wait +100) + _ (promise.wait 100) output (promise.future (atom.read output))] (assert "Apply works over all channel values." - (list/= (list 12346) + (list/= (list +12346) (list.reverse output))))) (wrap (do promise.Monad<Promise> [output (promise.future (read! (do frp.Monad<Channel> - [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) + [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) output (promise.future (atom.read output))] (assert "Valid monad." - (list/= (list 12346) + (list/= (list +12346) (list.reverse output))))) ))) diff --git a/stdlib/test/test/lux/concurrency/promise.lux b/stdlib/test/test/lux/concurrency/promise.lux index 76c5df05c..e857d0708 100644 --- a/stdlib/test/test/lux/concurrency/promise.lux +++ b/stdlib/test/test/lux/concurrency/promise.lux @@ -18,7 +18,7 @@ running?))) (wrap (do &.Monad<Promise> - [_ (&.wait +500)] + [_ (&.wait 500)] (assert "Can wait for a specified amount of time." #1))) @@ -29,10 +29,10 @@ (and left (not right))))) (wrap (do &.Monad<Promise> - [?left (&.or (&.delay +100 #1) - (&.delay +200 #0)) - ?right (&.or (&.delay +200 #1) - (&.delay +100 #0))] + [?left (&.or (&.delay 100 #1) + (&.delay 200 #0)) + ?right (&.or (&.delay 200 #1) + (&.delay 100 #0))] (assert "Can combine promises alternatively." (case [?left ?right] [(#.Left #1) (#.Right #0)] @@ -42,17 +42,17 @@ #0)))) (wrap (do &.Monad<Promise> - [?left (&.either (&.delay +100 #1) - (&.delay +200 #0)) - ?right (&.either (&.delay +200 #1) - (&.delay +100 #0))] + [?left (&.either (&.delay 100 #1) + (&.delay 200 #0)) + ?right (&.either (&.delay 200 #1) + (&.delay 100 #0))] (assert "Can combine promises alternatively [Part 2]." (and ?left (not ?right))))) (test "Can poll a promise for its value." (and (|> (&.poll (&/wrap #1)) (case> (#.Some #1) #1 _ #0)) - (|> (&.poll (&.delay +200 #1)) + (|> (&.poll (&.delay 200 #1)) (case> #.None #1 _ #0)))) (test "Cannot re-resolve a resolved promise." @@ -60,8 +60,8 @@ (io.run (&.resolve #1 (: (&.Promise Bit) (&.promise #.None)))))) (wrap (do &.Monad<Promise> - [?none (&.time-out +100 (&.delay +200 #1)) - ?some (&.time-out +200 (&.delay +100 #1))] + [?none (&.time-out 100 (&.delay 200 #1)) + ?some (&.time-out 200 (&.delay 100 #1))] (assert "Can establish maximum waiting times for promises to be fulfilled." (case [?none ?some] [#.None (#.Some #1)] diff --git a/stdlib/test/test/lux/concurrency/semaphore.lux b/stdlib/test/test/lux/concurrency/semaphore.lux index df145ff82..f309fcd0c 100644 --- a/stdlib/test/test/lux/concurrency/semaphore.lux +++ b/stdlib/test/test/lux/concurrency/semaphore.lux @@ -20,16 +20,16 @@ (def: (wait-many-times times semaphore) (-> Nat /.Semaphore (Promise Any)) (loop [steps times] - (if (n/> +0 steps) + (if (n/> 0 steps) (do promise.Monad<Promise> [_ (/.wait semaphore)] (recur (dec steps))) (:: promise.Monad<Promise> wrap [])))) (context: "Semaphore." - (<| (times +100) + (<| (times 100) (do @ - [open-positions (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1))))] + [open-positions (|> r.nat (:: @ map (|>> (n/% 10) (n/max 1))))] ($_ seq (let [semaphore (/.semaphore open-positions)] (wrap (do promise.Monad<Promise> @@ -38,7 +38,7 @@ #1)))) (let [semaphore (/.semaphore open-positions)] (wrap (do promise.Monad<Promise> - [result (<| (promise.time-out +100) + [result (<| (promise.time-out 100) (wait-many-times (inc open-positions) semaphore))] (assert "Waiting on a semaphore more than the number of open positions blocks the process." (case result @@ -50,8 +50,8 @@ (let [semaphore (/.semaphore open-positions)] (wrap (do promise.Monad<Promise> [_ (: (Promise Any) - (loop [steps (n/* +2 open-positions)] - (if (n/> +0 steps) + (loop [steps (n/* 2 open-positions)] + (if (n/> 0 steps) (do @ [_ (/.wait semaphore) _ (/.signal semaphore)] @@ -68,7 +68,7 @@ #let [_ (io.run (atom.update (|>> (format "B")) resource))]] (wrap []))] - _ (promise.wait +100) + _ (promise.wait 100) _ (exec (io.run (atom.update (|>> (format "A")) resource)) (/.signal semaphore)) @@ -79,9 +79,9 @@ )))) (context: "Mutex." - (<| (times +100) + (<| (times 100) (do @ - [repetitions (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10))))] + [repetitions (|> r.nat (:: @ map (|>> (n/% 100) (n/max 10))))] ($_ seq (let [mutex (/.mutex [])] (wrap (do promise.Monad<Promise> @@ -122,12 +122,12 @@ (wrap []))) (context: "Barrier." - (let [limit +10 + (let [limit 10 barrier (/.barrier (maybe.assume (/.limit limit))) resource (atom.atom "")] ($_ seq (wrap (do promise.Monad<Promise> - [#let [ids (list.n/range +0 (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 a1897b846..3506146f4 100644 --- a/stdlib/test/test/lux/concurrency/stm.lux +++ b/stdlib/test/test/lux/concurrency/stm.lux @@ -28,45 +28,45 @@ channel)] (wrap output))) -(def: iterations-per-process Nat +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." - (n/= +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." - (n/= +5 output)))) + (n/= 5 output)))) (wrap (do promise.Monad<Promise> - [#let [_var (&.var +5)] + [#let [_var (&.var 5)] output (&.commit (do &.Monad<STM> - [_ (&.update (n/* +3) _var)] + [_ (&.update (n/* 3) _var)] (&.read _var)))] (assert "Can update STM vars." - (n/= +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 (n/* +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.Equivalence<List> number.Equivalence<Nat>) = - (list +5 +15) + (list 5 15) (list.reverse changes))))) - (wrap (let [_concurrency-var (&.var +0)] + (wrap (let [_concurrency-var (&.var 0)] (do promise.Monad<Promise> [_ (|> promise.parallelism - (list.n/range +1) + (list.n/range 1) (list/map (function (_ _) (|> iterations-per-process - (list.n/range +1) + (list.n/range 1) (M.map @ (function (_ _) (&.commit (&.update inc _concurrency-var))))))) (M.seq @)) last-val (&.commit (&.read _concurrency-var))] diff --git a/stdlib/test/test/lux/control/continuation.lux b/stdlib/test/test/lux/control/continuation.lux index be7ac920c..dfe93023a 100644 --- a/stdlib/test/test/lux/control/continuation.lux +++ b/stdlib/test/test/lux/control/continuation.lux @@ -11,12 +11,12 @@ lux/test) (context: "Continuations" - (<| (times +100) + (<| (times 100) (do @ [sample r.nat #let [(^open "&/.") &.Apply<Cont> (^open "&/.") &.Monad<Cont>] - elems (r.list +3 r.nat)] + elems (r.list 3 r.nat)] ($_ seq (test "Can run continuations to compute their values." (n/= sample (&.run (&/wrap sample)))) @@ -34,7 +34,7 @@ (wrap (func arg)))))) (test "Can use the current-continuation as a escape hatch." - (n/= (n/* +2 sample) + (n/= (n/* 2 sample) (&.run (do &.Monad<Cont> [value (&.call/cc (function (_ k) @@ -42,16 +42,16 @@ [temp (k sample)] ## If this code where to run, ## the output would be - ## (n/* +4 sample) + ## (n/* 4 sample) (k temp))))] - (wrap (n/* +2 value)))))) + (wrap (n/* 2 value)))))) (test "Can use the current-continuation to build a time machine." - (n/= (n/+ +100 sample) + (n/= (n/+ 100 sample) (&.run (do &.Monad<Cont> - [[restart [output idx]] (&.portal [sample +0])] - (if (n/< +10 idx) - (restart [(n/+ +10 output) (inc idx)]) + [[restart [output idx]] (&.portal [sample 0])] + (if (n/< 10 idx) + (restart [(n/+ 10 output) (inc idx)]) (wrap output)))))) (test "Can use delimited continuations with shifting." diff --git a/stdlib/test/test/lux/control/exception.lux b/stdlib/test/test/lux/control/exception.lux index c1aa9d08e..36555f490 100644 --- a/stdlib/test/test/lux/control/exception.lux +++ b/stdlib/test/test/lux/control/exception.lux @@ -18,7 +18,7 @@ (exception: unknown-exception) (context: "Exceptions" - (<| (times +100) + (<| (times 100) (do @ [should-throw? r.bit which? r.bit diff --git a/stdlib/test/test/lux/control/interval.lux b/stdlib/test/test/lux/control/interval.lux index ba2e3c7b3..9fe01a0a1 100644 --- a/stdlib/test/test/lux/control/interval.lux +++ b/stdlib/test/test/lux/control/interval.lux @@ -14,7 +14,7 @@ ["L" list]]]]) (context: "Equivalence." - (<| (times +100) + (<| (times 100) (do @ [bottom r.int top r.int @@ -29,7 +29,7 @@ (&/= self self)))))))) (context: "Boundaries" - (<| (times +100) + (<| (times 100) (do @ [bottom r.int top r.int @@ -85,7 +85,7 @@ gen-singleton)) (context: "Unions" - (<| (times +100) + (<| (times 100) (do @ [some-interval gen-interval left-inner gen-inner @@ -107,7 +107,7 @@ )))) (context: "Intersections" - (<| (times +100) + (<| (times 100) (do @ [some-interval gen-interval left-inner gen-inner @@ -129,7 +129,7 @@ )))) (context: "Complement" - (<| (times +100) + (<| (times 100) (do @ [some-interval gen-interval #let [(^open "&/.") &.Equivalence<Interval>]] @@ -141,9 +141,9 @@ )))) (context: "Positioning/location" - (<| (times +100) + (<| (times 100) (do @ - [[l m r] (|> (r.set number.Hash<Int> +3 r.int) + [[l m r] (|> (r.set number.Hash<Int> 3 r.int) (:: @ map (|>> S.to-list (L.sort i/<) (case> (^ (list b t1 t2)) @@ -163,9 +163,9 @@ )))) (context: "Touching intervals" - (<| (times +100) + (<| (times 100) (do @ - [[b t1 t2] (|> (r.set number.Hash<Int> +3 r.int) + [[b t1 t2] (|> (r.set number.Hash<Int> 3 r.int) (:: @ map (|>> S.to-list (L.sort i/<) (case> (^ (list b t1 t2)) @@ -189,10 +189,10 @@ )))) (context: "Nesting & overlap" - (<| (times +100) + (<| (times 100) (do @ [some-interval gen-interval - [x0 x1 x2 x3] (|> (r.set number.Hash<Int> +4 r.int) + [x0 x1 x2 x3] (|> (r.set number.Hash<Int> 4 r.int) (:: @ map (|>> S.to-list (L.sort i/<) (case> (^ (list x0 x1 x2 x3)) diff --git a/stdlib/test/test/lux/control/parser.lux b/stdlib/test/test/lux/control/parser.lux index 505ee4b55..378cbccd4 100644 --- a/stdlib/test/test/lux/control/parser.lux +++ b/stdlib/test/test/lux/control/parser.lux @@ -59,35 +59,35 @@ (context: "Assertions" (test "Can make assertions while parsing." (and (match [] - (&.run (list (code.bit #1) (code.int 123)) + (&.run (list (code.bit #1) (code.int +123)) (&.assert "yolo" #1))) - (fails? (&.run (list (code.bit #1) (code.int 123)) + (fails? (&.run (list (code.bit #1) (code.int +123)) (&.assert "yolo" #0)))))) (context: "Combinators [Part 1]" ($_ seq (test "Can optionally succeed with some parser." - (and (match (#.Some +123) - (&.run (list (code.nat +123)) + (and (match (#.Some 123) + (&.run (list (code.nat 123)) (&.maybe s.nat))) (match #.None (&.run (list (code.int -123)) (&.maybe s.nat))))) (test "Can apply a parser 0 or more times." - (and (match (list +123 +456 +789) - (&.run (list (code.nat +123) (code.nat +456) (code.nat +789)) + (and (match (list 123 456 789) + (&.run (list (code.nat 123) (code.nat 456) (code.nat 789)) (&.some s.nat))) (match (list) (&.run (list (code.int -123)) (&.some s.nat))))) (test "Can apply a parser 1 or more times." - (and (match (list +123 +456 +789) - (&.run (list (code.nat +123) (code.nat +456) (code.nat +789)) + (and (match (list 123 456 789) + (&.run (list (code.nat 123) (code.nat 456) (code.nat 789)) (&.many s.nat))) - (match (list +123) - (&.run (list (code.nat +123)) + (match (list 123) + (&.run (list (code.nat 123)) (&.many s.nat))) (fails? (&.run (list (code.int -123)) (&.many s.nat))))) @@ -96,22 +96,22 @@ (let [positive (: (s.Syntax Int) (do &.Monad<Parser> [value s.int - _ (&.assert "" (i/> 0 value))] + _ (&.assert "" (i/> +0 value))] (wrap value)))] - (and (match 123 - (&.run (list (code.int 123) (code.int 456) (code.int 789)) + (and (match +123 + (&.run (list (code.int +123) (code.int +456) (code.int +789)) (&.either positive s.int))) (match -123 - (&.run (list (code.int -123) (code.int 456) (code.int 789)) + (&.run (list (code.int -123) (code.int +456) (code.int +789)) (&.either positive s.int))) - (fails? (&.run (list (code.bit #1) (code.int 456) (code.int 789)) + (fails? (&.run (list (code.bit #1) (code.int +456) (code.int +789)) (&.either positive s.int)))))) (test "Can create the opposite/negation of any parser." - (and (fails? (&.run (list (code.int 123) (code.int 456) (code.int 789)) + (and (fails? (&.run (list (code.int +123) (code.int +456) (code.int +789)) (&.not s.int))) (match [] - (&.run (list (code.bit #1) (code.int 456) (code.int 789)) + (&.run (list (code.bit #1) (code.int +456) (code.int +789)) (&.not s.int))))) )) @@ -122,53 +122,53 @@ (&.fail "Well, it really SHOULD fail...")))) (test "Can apply a parser N times." - (and (match (list 123 456 789) - (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.exactly +3 s.int))) - (match (list 123 456) - (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.exactly +2 s.int))) - (fails? (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.exactly +4 s.int))))) + (and (match (list +123 +456 +789) + (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.exactly 3 s.int))) + (match (list +123 +456) + (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.exactly 2 s.int))) + (fails? (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.exactly 4 s.int))))) (test "Can apply a parser at-least N times." - (and (match (list 123 456 789) - (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.at-least +3 s.int))) - (match (list 123 456 789) - (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.at-least +2 s.int))) - (fails? (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.at-least +4 s.int))))) + (and (match (list +123 +456 +789) + (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.at-least 3 s.int))) + (match (list +123 +456 +789) + (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.at-least 2 s.int))) + (fails? (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.at-least 4 s.int))))) (test "Can apply a parser at-most N times." - (and (match (list 123 456 789) - (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.at-most +3 s.int))) - (match (list 123 456) - (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.at-most +2 s.int))) - (match (list 123 456 789) - (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.at-most +4 s.int))))) + (and (match (list +123 +456 +789) + (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.at-most 3 s.int))) + (match (list +123 +456) + (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.at-most 2 s.int))) + (match (list +123 +456 +789) + (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.at-most 4 s.int))))) (test "Can apply a parser between N and M times." - (and (match (list 123 456 789) - (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.between +3 +10 s.int))) - (fails? (&.run (list (code.int 123) (code.int 456) (code.int 789)) - (&.between +4 +10 s.int))))) + (and (match (list +123 +456 +789) + (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.between 3 10 s.int))) + (fails? (&.run (list (code.int +123) (code.int +456) (code.int +789)) + (&.between 4 10 s.int))))) (test "Can parse while taking separators into account." - (and (match (list 123 456 789) - (&.run (list (code.int 123) (code.text "YOLO") (code.int 456) (code.text "YOLO") (code.int 789)) + (and (match (list +123 +456 +789) + (&.run (list (code.int +123) (code.text "YOLO") (code.int +456) (code.text "YOLO") (code.int +789)) (&.sep-by (s.this (' "YOLO")) s.int))) - (match (list 123 456) - (&.run (list (code.int 123) (code.text "YOLO") (code.int 456) (code.int 789)) + (match (list +123 +456) + (&.run (list (code.int +123) (code.text "YOLO") (code.int +456) (code.int +789)) (&.sep-by (s.this (' "YOLO")) s.int))))) (test "Can obtain the whole of the remaining input." (|> &.remaining - (&.run (list (code.int 123) (code.int 456) (code.int 789))) - (match (list [_ (#.Int 123)] [_ (#.Int 456)] [_ (#.Int 789)])))) + (&.run (list (code.int +123) (code.int +456) (code.int +789))) + (match (list [_ (#.Int +123)] [_ (#.Int +456)] [_ (#.Int +789)])))) )) diff --git a/stdlib/test/test/lux/control/pipe.lux b/stdlib/test/test/lux/control/pipe.lux index 2cc09fbf8..e5ceaeb19 100644 --- a/stdlib/test/test/lux/control/pipe.lux +++ b/stdlib/test/test/lux/control/pipe.lux @@ -14,59 +14,59 @@ (context: "Pipes" ($_ seq (test "Can dismiss previous pipeline results and begin a new line." - (|> 20 - (i/* 3) - (i/+ 4) - (new> 0 inc) - (i/= 1))) + (|> +20 + (i/* +3) + (i/+ +4) + (new> +0 inc) + (i/= +1))) (test "Can give names to piped values within a pipeline's scope." - (|> 5 + (|> +5 (let> X [(i/+ X X)]) - (i/= 10))) + (i/= +10))) (test "Can do branching in pipelines." - (and (|> 5 - (cond> [i/even?] [(i/* 2)] - [i/odd?] [(i/* 3)] + (and (|> +5 + (cond> [i/even?] [(i/* +2)] + [i/odd?] [(i/* +3)] [(new> -1)]) - (i/= 15)) - (|> 4 - (cond> [i/even?] [(i/* 2)] - [i/odd?] [(i/* 3)] + (i/= +15)) + (|> +4 + (cond> [i/even?] [(i/* +2)] + [i/odd?] [(i/* +3)] []) - (i/= 8)) - (|> 5 - (cond> [i/even?] [(i/* 2)] + (i/= +8)) + (|> +5 + (cond> [i/even?] [(i/* +2)] [(new> -1)]) (i/= -1)))) (test "Can loop within pipelines." - (|> 1 - (loop> [(i/< 10)] + (|> +1 + (loop> [(i/< +10)] [inc]) - (i/= 10))) + (i/= +10))) (test "Can use monads within pipelines." - (|> 5 + (|> +5 (do> Monad<Identity> - [(i/* 3)] - [(i/+ 4)] + [(i/* +3)] + [(i/+ +4)] [inc]) - (i/= 20))) + (i/= +20))) (test "Can pattern-match against piped values." - (|> 5 - (case> 0 "zero" - 1 "one" - 2 "two" - 3 "three" - 4 "four" - 5 "five" - 6 "six" - 7 "seven" - 8 "eight" - 9 "nine" + (|> +5 + (case> +0 "zero" + +1 "one" + +2 "two" + +3 "three" + +4 "four" + +5 "five" + +6 "six" + +7 "seven" + +8 "eight" + +9 "nine" _ "???") (text/= "five"))) )) diff --git a/stdlib/test/test/lux/control/reader.lux b/stdlib/test/test/lux/control/reader.lux index 135cce4ee..57f487426 100644 --- a/stdlib/test/test/lux/control/reader.lux +++ b/stdlib/test/test/lux/control/reader.lux @@ -11,27 +11,27 @@ (let [(^open "&/.") &.Apply<Reader> (^open "&/.") &.Monad<Reader>] ($_ seq - (test "" (i/= 123 (&.run 123 &.ask))) - (test "" (i/= 246 (&.run 123 (&.local (i/* 2) &.ask)))) - (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> - [f (wrap i/+) - x (wrap 10) - y (wrap 20)] - (wrap (f x y))))))))) + (test "" (i/= +123 (&.run +123 &.ask))) + (test "" (i/= +246 (&.run +123 (&.local (i/* +2) &.ask)))) + (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> + [f (wrap i/+) + x (wrap +10) + y (wrap +20)] + (wrap (f x y))))))))) (context: "Monad transformer" (let [(^open "io/.") io.Monad<IO>] (test "Can add reader functionality to any monad." (|> (: (&.Reader Text (io.IO Int)) (do (&.ReaderT io.Monad<IO>) - [a (&.lift (io/wrap 123)) - b (wrap 456)] + [a (&.lift (io/wrap +123)) + b (wrap +456)] (wrap (i/+ a b)))) (&.run "") io.run - (case> 579 #1 - _ #0))) + (case> +579 #1 + _ #0))) )) diff --git a/stdlib/test/test/lux/control/region.lux b/stdlib/test/test/lux/control/region.lux index b6cd43ea7..8a419bb0a 100644 --- a/stdlib/test/test/lux/control/region.lux +++ b/stdlib/test/test/lux/control/region.lux @@ -27,14 +27,14 @@ ) (context: "Regions." - (<| (times +100) + (<| (times 100) (do @ - [expected-clean-ups (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1))))] + [expected-clean-ups (|> r.nat (:: @ map (|>> (n/% 100) (n/max 1))))] ($_ seq (test "Clean-up functions are always run when region execution is done." (thread.run (do thread.Monad<Thread> - [clean-up-counter (thread.box +0) + [clean-up-counter (thread.box 0) #let [@@ @ count-clean-up (function (_ value) (do @ @@ -43,7 +43,7 @@ outcome (/.run @ (do (/.Monad<Region> @) [_ (monad.map @ (/.acquire @@ count-clean-up) - (list.n/range +1 expected-clean-ups))] + (list.n/range 1 expected-clean-ups))] (wrap []))) actual-clean-ups (thread.read clean-up-counter)] (wrap (and (success? outcome) @@ -52,7 +52,7 @@ (test "Can clean-up despite errors." (thread.run (do thread.Monad<Thread> - [clean-up-counter (thread.box +0) + [clean-up-counter (thread.box 0) #let [@@ @ count-clean-up (function (_ value) (do @ @@ -61,7 +61,7 @@ outcome (/.run @ (do (/.Monad<Region> @) [_ (monad.map @ (/.acquire @@ count-clean-up) - (list.n/range +1 expected-clean-ups)) + (list.n/range 1 expected-clean-ups)) _ (/.throw @@ oops [])] (wrap []))) actual-clean-ups (thread.read clean-up-counter)] @@ -71,7 +71,7 @@ (test "Errors can propagate from the cleaners." (thread.run (do thread.Monad<Thread> - [clean-up-counter (thread.box +0) + [clean-up-counter (thread.box 0) #let [@@ @ count-clean-up (function (_ value) (do @ @@ -80,17 +80,17 @@ outcome (/.run @ (do (/.Monad<Region> @) [_ (monad.map @ (/.acquire @@ count-clean-up) - (list.n/range +1 expected-clean-ups))] + (list.n/range 1 expected-clean-ups))] (wrap []))) actual-clean-ups (thread.read clean-up-counter)] - (wrap (and (or (n/= +0 expected-clean-ups) + (wrap (and (or (n/= 0 expected-clean-ups) (error? outcome)) (n/= expected-clean-ups actual-clean-ups)))))) (test "Can lift operations." (thread.run (do thread.Monad<Thread> - [clean-up-counter (thread.box +0) + [clean-up-counter (thread.box 0) #let [@@ @] outcome (/.run @ (do (/.Monad<Region> @) diff --git a/stdlib/test/test/lux/control/state.lux b/stdlib/test/test/lux/control/state.lux index e7f26bfe3..45f8675d8 100644 --- a/stdlib/test/test/lux/control/state.lux +++ b/stdlib/test/test/lux/control/state.lux @@ -19,7 +19,7 @@ (n/= output))) (context: "Basics" - (<| (times +100) + (<| (times 100) (do @ [state r.nat value r.nat] @@ -47,7 +47,7 @@ )))) (context: "Structures" - (<| (times +100) + (<| (times 100) (do @ [state r.nat value r.nat @@ -75,7 +75,7 @@ )))) (context: "Monad transformer" - (<| (times +100) + (<| (times 100) (do @ [state r.nat left r.nat @@ -95,23 +95,23 @@ )))) (context: "Loops" - (<| (times +100) + (<| (times 100) (do @ - [limit (|> r.nat (:: @ map (n/% +10))) + [limit (|> r.nat (:: @ map (n/% 10))) #let [condition (do &.Monad<State> [state &.get] (wrap (n/< limit state)))]] ($_ seq (test "'while' will only execute if the condition is #1." (|> (&.while condition (&.update inc)) - (&.run +0) + (&.run 0) (case> [state' output'] (n/= limit state')))) (test "'do-while' will execute at least once." (|> (&.do-while condition (&.update inc)) - (&.run +0) + (&.run 0) (case> [state' output'] (or (n/= limit state') - (and (n/= +0 limit) - (n/= +1 state')))))) + (and (n/= 0 limit) + (n/= 1 state')))))) )))) diff --git a/stdlib/test/test/lux/control/thread.lux b/stdlib/test/test/lux/control/thread.lux index 8c7dcc592..d9867f4bc 100644 --- a/stdlib/test/test/lux/control/thread.lux +++ b/stdlib/test/test/lux/control/thread.lux @@ -7,15 +7,15 @@ (def: _test0_ Nat (/.run (do /.Monad<Thread> - [box (/.box +123) - old (/.update (n/* +2) box) + [box (/.box 123) + old (/.update (n/* 2) box) new (/.read box)] (wrap (n/+ old new))))) (def: _test1_ (All [!] (/.Thread ! Nat)) (do /.Monad<Thread> - [box (/.box +123) - old (/.update (n/* +2) box) + [box (/.box 123) + old (/.update (n/* 2) box) new (/.read box)] (wrap (n/+ old new)))) diff --git a/stdlib/test/test/lux/control/writer.lux b/stdlib/test/test/lux/control/writer.lux index 6b31046ea..de8bdc599 100644 --- a/stdlib/test/test/lux/control/writer.lux +++ b/stdlib/test/test/lux/control/writer.lux @@ -15,18 +15,18 @@ (^open "&/.") (&.Apply<Writer> text.Monoid<Text>)] ($_ seq (test "Functor respects Writer." - (i/= 11 (product.right (&/map inc ["" 10])))) + (i/= +11 (product.right (&/map inc ["" +10])))) (test "Apply respects Writer." - (and (i/= 20 (product.right (&/wrap 20))) - (i/= 30 (product.right (&/apply (&/wrap (i/+ 10)) (&/wrap 20)))))) + (and (i/= +20 (product.right (&/wrap +20))) + (i/= +30 (product.right (&/apply (&/wrap (i/+ +10)) (&/wrap +20)))))) (test "Monad respects Writer." - (i/= 30 (product.right (do (&.Monad<Writer> text.Monoid<Text>) - [f (wrap i/+) - a (wrap 10) - b (wrap 20)] - (wrap (f a b)))))) + (i/= +30 (product.right (do (&.Monad<Writer> text.Monoid<Text>) + [f (wrap i/+) + a (wrap +10) + b (wrap +20)] + (wrap (f a b)))))) (test "Can log any value." (text/= "YOLO" (product.left (&.log "YOLO")))) @@ -37,9 +37,9 @@ (^open "io/.") io.Monad<IO>] (test "Can add writer functionality to any monad." (|> (io.run (do (&.WriterT text.Monoid<Text> io.Monad<IO>) - [a (lift (io/wrap 123)) - b (wrap 456)] + [a (lift (io/wrap +123)) + b (wrap +456)] (wrap (i/+ a b)))) - (case> ["" 579] #1 - _ #0))) + (case> ["" +579] #1 + _ #0))) )) diff --git a/stdlib/test/test/lux/data/bit.lux b/stdlib/test/test/lux/data/bit.lux index 7eea70f7a..ecb0c90ad 100644 --- a/stdlib/test/test/lux/data/bit.lux +++ b/stdlib/test/test/lux/data/bit.lux @@ -9,7 +9,7 @@ lux/test) (context: "Bit operations." - (<| (times +100) + (<| (times 100) (do @ [value r.bit] (test "" (and (not (and value (not value))) diff --git a/stdlib/test/test/lux/data/collection/array.lux b/stdlib/test/test/lux/data/collection/array.lux index 0e42c7132..ac3061464 100644 --- a/stdlib/test/test/lux/data/collection/array.lux +++ b/stdlib/test/test/lux/data/collection/array.lux @@ -16,10 +16,10 @@ (def: bounded-size (r.Random Nat) (|> r.nat - (:: r.Monad<Random> map (|>> (n/% +100) (n/+ +1))))) + (:: r.Monad<Random> map (|>> (n/% 100) (n/+ 1))))) (context: "Arrays and their copies" - (<| (times +100) + (<| (times 100) (do @ [size bounded-size original (r.array size r.nat) @@ -35,7 +35,7 @@ (and (:: (@.Equivalence<Array> number.Equivalence<Nat>) = original clone) (not (is? original clone)))) (test "Full-range manual copies should give the same result as cloning." - (exec (@.copy size +0 original +0 copy) + (exec (@.copy size 0 original 0 copy) (and (:: (@.Equivalence<Array> number.Equivalence<Nat>) = original copy) (not (is? original copy))))) (test "Array folding should go over all values." @@ -43,7 +43,7 @@ (function (_ x idx) (exec (@.write idx x manual-copy) (inc idx))) - +0 + 0 original) (:: (@.Equivalence<Array> number.Equivalence<Nat>) = original manual-copy))) (test "Transformations between (full) arrays and lists shouldn't cause lose or change any values." @@ -53,7 +53,7 @@ )))) (context: "Array mutation" - (<| (times +100) + (<| (times 100) (do @ [size bounded-size idx (:: @ map (n/% size) r.nat) @@ -71,17 +71,17 @@ #.None #0)) (test "All cells should be occupied on a full array." (and (n/= size (@.occupied array)) - (n/= +0 (@.vacant array)))) + (n/= 0 (@.vacant array)))) (test "Filtering mutates the array to remove invalid values." (exec (@.filter n/even? array) (and (n/< size (@.occupied array)) - (n/> +0 (@.vacant array)) + (n/> 0 (@.vacant array)) (n/= size (n/+ (@.occupied array) (@.vacant array)))))) )))) (context: "Finding values." - (<| (times +100) + (<| (times 100) (do @ [size bounded-size array (|> (r.array size r.nat) @@ -100,7 +100,7 @@ #.None #0))))))) (context: "Functor" - (<| (times +100) + (<| (times 100) (do @ [size bounded-size array (r.array size r.nat)] @@ -118,7 +118,7 @@ (= array back-again))))))))) (context: "Monoid" - (<| (times +100) + (<| (times 100) (do @ [sizeL bounded-size sizeR bounded-size @@ -133,11 +133,11 @@ (test "First elements of fused array should equal the first array." (|> (: (Array Nat) (@.new sizeL)) - (@.copy sizeL +0 fusion +0) + (@.copy sizeL 0 fusion 0) (= left))) (test "Last elements of fused array should equal the second array." (|> (: (Array Nat) (@.new sizeR)) - (@.copy sizeR sizeL fusion +0) + (@.copy sizeR sizeL fusion 0) (= right))) )))) diff --git a/stdlib/test/test/lux/data/collection/bits.lux b/stdlib/test/test/lux/data/collection/bits.lux index c9c1a1b85..91ab7b828 100644 --- a/stdlib/test/test/lux/data/collection/bits.lux +++ b/stdlib/test/test/lux/data/collection/bits.lux @@ -22,14 +22,14 @@ (def: bits (r.Random /.Bits) (do r.Monad<Random> - [size (size +1 +1_000) + [size (size 1 1_000) idx (|> r.nat (:: @ map (n/% size)))] (wrap (|> /.empty (/.set idx))))) (context: "Bits." - (<| (times +100) + (<| (times 100) (do @ - [size (size +1 +1_000) + [size (size 1 1_000) idx (|> r.nat (:: @ map (n/% size))) sample bits] ($_ seq @@ -43,14 +43,14 @@ (|> /.empty (/.flip idx) (/.flip idx) (/.get idx) not))) (test "Bits (only) grow when (and as much as) necessary." - (and (n/= +0 (/.capacity /.empty)) + (and (n/= 0 (/.capacity /.empty)) (|> /.empty (/.set idx) /.capacity (n/- idx) - (predicate.union (n/>= +0) + (predicate.union (n/>= 0) (n/< /.chunk-size))))) (test "Bits (must) shrink when (and as much as) possible." (let [grown (/.flip idx /.empty)] - (and (n/> +0 (/.capacity grown)) + (and (n/> 0 (/.capacity grown)) (is? /.empty (/.flip idx grown))))) (test "Intersection can be detected when there are set bits in common." diff --git a/stdlib/test/test/lux/data/collection/dictionary.lux b/stdlib/test/test/lux/data/collection/dictionary.lux index aec463ec8..466cb2872 100644 --- a/stdlib/test/test/lux/data/collection/dictionary.lux +++ b/stdlib/test/test/lux/data/collection/dictionary.lux @@ -14,9 +14,9 @@ lux/test) (context: "Dictionaries." - (<| (times +100) + (<| (times 100) (do @ - [#let [capped-nat (:: r.Monad<Random> map (n/% +100) r.nat)] + [#let [capped-nat (:: r.Monad<Random> map (n/% 100) r.nat)] size capped-nat dict (r.dictionary number.Hash<Nat> size r.nat capped-nat) non-key (|> r.nat (r.filter (function (_ key) (not (&.contains? key dict))))) @@ -26,7 +26,7 @@ (n/= size (&.size dict))) (test "Dictionaries of size 0 should be considered empty." - (if (n/= +0 size) + (if (n/= 0 size) (&.empty? dict) (not (&.empty? dict)))) @@ -62,7 +62,7 @@ _ #1)) (test "Shouldn't be able to put~ an existing key." - (or (n/= +0 size) + (or (n/= 0 size) (let [first-key (|> dict &.keys list.head maybe.assume)] (case (&.get first-key (&.put~ first-key test-val dict)) (#.Some v) (not (n/= test-val v)) @@ -106,7 +106,7 @@ (= dict' (&.merge dict' dict)))) (test "Can merge values in such a way that they become combined." - (list.every? (function (_ [x x*2]) (n/= (n/* +2 x) x*2)) + (list.every? (function (_ [x x*2]) (n/= (n/* 2 x) x*2)) (list.zip2 (&.values dict) (&.values (&.merge-with n/+ dict dict))))) @@ -115,10 +115,10 @@ (&.put non-key test-val) (&.select (list non-key)) &.size - (n/= +1))) + (n/= 1))) (test "Should be able to re-bind existing values to different keys." - (or (n/= +0 size) + (or (n/= 0 size) (let [first-key (|> dict &.keys list.head maybe.assume) rebound (&.re-bind first-key non-key dict)] (and (n/= (&.size dict) (&.size rebound)) diff --git a/stdlib/test/test/lux/data/collection/dictionary/ordered.lux b/stdlib/test/test/lux/data/collection/dictionary/ordered.lux index b3d917625..a8246887e 100644 --- a/stdlib/test/test/lux/data/collection/dictionary/ordered.lux +++ b/stdlib/test/test/lux/data/collection/dictionary/ordered.lux @@ -16,9 +16,9 @@ lux/test) (context: "Dictionary" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (n/% +100))) + [size (|> r.nat (:: @ map (n/% 100))) keys (r.set number.Hash<Nat> size r.nat) values (r.set number.Hash<Nat> size r.nat) extra-key (|> r.nat (r.filter (|>> (s.member? keys) not))) diff --git a/stdlib/test/test/lux/data/collection/list.lux b/stdlib/test/test/lux/data/collection/list.lux index 2afdcefe2..31d5d6155 100644 --- a/stdlib/test/test/lux/data/collection/list.lux +++ b/stdlib/test/test/lux/data/collection/list.lux @@ -18,10 +18,10 @@ (def: bounded-size (r.Random Nat) (|> r.nat - (:: r.Monad<Random> map (|>> (n/% +100) (n/+ +10))))) + (:: r.Monad<Random> map (|>> (n/% 100) (n/+ 10))))) (context: "Lists: Part 1" - (<| (times +100) + (<| (times 100) (do @ [size bounded-size idx (:: @ map (n/% size) r.nat) @@ -67,7 +67,7 @@ )))) (context: "Lists: Part 2" - (<| (times +100) + (<| (times 100) (do @ [size bounded-size idx (:: @ map (n/% size) r.nat) @@ -115,7 +115,7 @@ ))) (test "Segmenting the list in pairs should yield as many elements as N/2." - (n/= (n// +2 size) + (n/= (n// 2 size) (&.size (&.as-pairs sample)))) (test "Sorting a list shouldn't change it's size." @@ -128,7 +128,7 @@ )))) (context: "Lists: Part 3" - (<| (times +100) + (<| (times 100) (do @ [size bounded-size idx (:: @ map (n/% size) r.nat) @@ -136,8 +136,8 @@ other-size bounded-size other-sample (r.list other-size r.nat) separator r.nat - from (|> r.nat (:: @ map (n/% +10))) - to (|> r.nat (:: @ map (n/% +10))) + from (|> r.nat (:: @ map (n/% 10))) + to (|> r.nat (:: @ map (n/% 10))) #let [(^open ".") (&.Equivalence<List> number.Equivalence<Nat>) (^open "&/.") &.Functor<List>]] ($_ seq @@ -167,7 +167,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) dec) + (and (n/= (|> size (n/* 2) dec) (&.size sample+)) (|> sample+ &.as-pairs (map product.right) (&.every? (n/= separator)))))) @@ -204,9 +204,9 @@ (&.every? (bit.complement n/even?) sample)))) (test "You can iteratively construct a list, generating values until you're done." - (= (&.n/range +0 (dec size)) + (= (&.n/range 0 (dec size)) (&.iterate (function (_ n) (if (n/< size n) (#.Some (inc n)) #.None)) - +0))) + 0))) (test "Can enumerate all elements in a list." (let [enum-sample (&.enumerate sample)] @@ -232,8 +232,8 @@ (^open "io/.") io.Monad<IO>] (test "Can add list functionality to any monad." (|> (io.run (do (&.ListT io.Monad<IO>) - [a (lift (io/wrap 123)) - b (wrap 456)] + [a (lift (io/wrap +123)) + b (wrap +456)] (wrap (i/+ a b)))) - (case> (^ (list 579)) #1 - _ #0))))) + (case> (^ (list +579)) #1 + _ #0))))) diff --git a/stdlib/test/test/lux/data/collection/queue.lux b/stdlib/test/test/lux/data/collection/queue.lux index 935f8f22b..9b21411fa 100644 --- a/stdlib/test/test/lux/data/collection/queue.lux +++ b/stdlib/test/test/lux/data/collection/queue.lux @@ -11,15 +11,15 @@ lux/test) (context: "Queues" - (<| (times +100) + (<| (times 100) (do @ - [size (:: @ map (n/% +100) r.nat) + [size (:: @ map (n/% 100) r.nat) sample (r.queue size r.nat) non-member (|> r.nat (r.filter (|>> (&.member? number.Equivalence<Nat> sample) not)))] ($_ seq (test "I can query the size of a queue (and empty queues have size 0)." - (if (n/= +0 size) + (if (n/= 0 size) (&.empty? sample) (n/= size (&.size sample)))) diff --git a/stdlib/test/test/lux/data/collection/queue/priority.lux b/stdlib/test/test/lux/data/collection/queue/priority.lux index b5f8a1d17..5450b8ad9 100644 --- a/stdlib/test/test/lux/data/collection/queue/priority.lux +++ b/stdlib/test/test/lux/data/collection/queue/priority.lux @@ -24,9 +24,9 @@ inputs))) (context: "Queues" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (n/% +100))) + [size (|> r.nat (:: @ map (n/% 100))) sample (gen-queue size) non-member-priority r.nat non-member (|> r.nat (r.filter (|>> (&.member? number.Equivalence<Nat> sample) not)))] @@ -37,7 +37,7 @@ (test "Enqueueing and dequeing affects the size of queues." (and (n/= (inc size) (&.size (&.push non-member-priority non-member sample))) - (or (n/= +0 (&.size sample)) + (or (n/= 0 (&.size sample)) (n/= (dec size) (&.size (&.pop sample)))))) @@ -46,7 +46,7 @@ (&.member? number.Equivalence<Nat> (&.push non-member-priority non-member sample) non-member)) - (or (n/= +0 (&.size sample)) + (or (n/= 0 (&.size sample)) (and (&.member? number.Equivalence<Nat> sample (maybe.assume (&.peek sample))) diff --git a/stdlib/test/test/lux/data/collection/row.lux b/stdlib/test/test/lux/data/collection/row.lux index ec6d7659d..09b443219 100644 --- a/stdlib/test/test/lux/data/collection/row.lux +++ b/stdlib/test/test/lux/data/collection/row.lux @@ -12,9 +12,9 @@ lux/test) (context: "Rows" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1)))) + [size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 1)))) idx (|> r.nat (:: @ map (n/% size))) sample (r.row size r.nat) other-sample (r.row size r.nat) @@ -27,8 +27,8 @@ ($_ seq (test "Can query size of row." (if (&.empty? sample) - (and (n/= +0 size) - (n/= +0 (&.size sample))) + (and (n/= 0 size) + (n/= 0 (&.size sample))) (n/= size (&.size sample)))) (test "Can add and remove elements to rows." @@ -56,8 +56,8 @@ (&.member? number.Equivalence<Nat> (&.add non-member sample) non-member))) (test "Can fold over elements of row." - (n/= (list/fold n/+ +0 (&.to-list sample)) - (&/fold n/+ +0 sample))) + (n/= (list/fold n/+ 0 (&.to-list sample)) + (&/fold n/+ 0 sample))) (test "Functor goes over every element." (let [there (&/map inc sample) diff --git a/stdlib/test/test/lux/data/collection/sequence.lux b/stdlib/test/test/lux/data/collection/sequence.lux index dd545e906..ce8ef1b4f 100644 --- a/stdlib/test/test/lux/data/collection/sequence.lux +++ b/stdlib/test/test/lux/data/collection/sequence.lux @@ -15,38 +15,38 @@ lux/test) (context: "Sequences" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +2)))) - offset (|> r.nat (:: @ map (n/% +100))) - factor (|> r.nat (:: @ map (|>> (n/% +100) (n/max +2)))) + [size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 2)))) + offset (|> r.nat (:: @ map (n/% 100))) + factor (|> r.nat (:: @ map (|>> (n/% 100) (n/max 2)))) elem r.nat cycle-seed (r.list size r.nat) - cycle-sample-idx (|> r.nat (:: @ map (n/% +1000))) + cycle-sample-idx (|> r.nat (:: @ map (n/% 1000))) #let [(^open "List/.") (list.Equivalence<List> number.Equivalence<Nat>) - sample0 (&.iterate inc +0) + sample0 (&.iterate inc 0) sample1 (&.iterate inc offset)]] ($_ seq (test "Can move along a sequence and take slices off it." - (and (and (List/= (list.n/range +0 (dec size)) + (and (and (List/= (list.n/range 0 (dec size)) (&.take size sample0)) (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 (dec size)) + (and (List/= (list.n/range 0 (dec size)) drops) - (List/= (list.n/range size (dec (n/* +2 size))) + (List/= (list.n/range size (dec (n/* 2 size))) (&.take size takes))))) - (and (List/= (list.n/range +0 (dec size)) + (and (List/= (list.n/range 0 (dec size)) (&.take-while (n/< size) sample0)) (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 (dec size)) + (and (List/= (list.n/range 0 (dec size)) drops) - (List/= (list.n/range size (dec (n/* +2 size))) - (&.take-while (n/< (n/* +2 size)) takes))))) + (List/= (list.n/range size (dec (n/* 2 size))) + (&.take-while (n/< (n/* 2 size)) takes))))) )) (test "Can repeat any element and infinite number of times." @@ -58,13 +58,13 @@ (&.take size (&.tail sample1))))) (test "Can filter sequences." - (and (n/= (n/* +2 offset) + (and (n/= (n/* 2 offset) (&.nth offset (&.filter n/even? sample0))) - (let [[evens odds] (&.partition n/even? (&.iterate inc +0))] - (and (n/= (n/* +2 offset) + (let [[evens odds] (&.partition n/even? (&.iterate inc 0))] + (and (n/= (n/* 2 offset) (&.nth offset evens)) - (n/= (inc (n/* +2 offset)) + (n/= (inc (n/* 2 offset)) (&.nth offset odds)))))) (test "Functor goes over 'all' elements in a sequence." diff --git a/stdlib/test/test/lux/data/collection/set.lux b/stdlib/test/test/lux/data/collection/set.lux index 78bb1bc42..1b94aed8c 100644 --- a/stdlib/test/test/lux/data/collection/set.lux +++ b/stdlib/test/test/lux/data/collection/set.lux @@ -14,10 +14,10 @@ (def: gen-nat (r.Random Nat) (|> r.nat - (:: r.Monad<Random> map (n/% +100)))) + (:: r.Monad<Random> map (n/% 100)))) (context: "Sets" - (<| (times +100) + (<| (times 100) (do @ [sizeL gen-nat sizeR gen-nat diff --git a/stdlib/test/test/lux/data/collection/set/ordered.lux b/stdlib/test/test/lux/data/collection/set/ordered.lux index fe7b3069c..7eb313c0f 100644 --- a/stdlib/test/test/lux/data/collection/set/ordered.lux +++ b/stdlib/test/test/lux/data/collection/set/ordered.lux @@ -17,10 +17,10 @@ (def: gen-nat (r.Random Nat) (|> r.nat - (:: r.Monad<Random> map (n/% +100)))) + (:: r.Monad<Random> map (n/% 100)))) (context: "Sets" - (<| (times +100) + (<| (times 100) (do @ [sizeL gen-nat sizeR gen-nat diff --git a/stdlib/test/test/lux/data/collection/stack.lux b/stdlib/test/test/lux/data/collection/stack.lux index 0be661232..954e72e78 100644 --- a/stdlib/test/test/lux/data/collection/stack.lux +++ b/stdlib/test/test/lux/data/collection/stack.lux @@ -13,10 +13,10 @@ (def: gen-nat (r.Random Nat) (|> r.nat - (:: r.Monad<Random> map (n/% +100)))) + (:: r.Monad<Random> map (n/% 100)))) (context: "Stacks" - (<| (times +100) + (<| (times 100) (do @ [size gen-nat sample (r.stack size gen-nat) diff --git a/stdlib/test/test/lux/data/collection/tree/rose.lux b/stdlib/test/test/lux/data/collection/tree/rose.lux index a891807b8..674ac1d47 100644 --- a/stdlib/test/test/lux/data/collection/tree/rose.lux +++ b/stdlib/test/test/lux/data/collection/tree/rose.lux @@ -19,19 +19,19 @@ (r.Random [Nat (&.Tree Nat)]) (r.rec (function (_ gen-tree) - (r.either (:: r.Monad<Random> map (|>> &.leaf [+1]) r.nat) + (r.either (:: r.Monad<Random> map (|>> &.leaf [1]) r.nat) (do r.Monad<Random> [value r.nat - num-children (|> r.nat (:: @ map (n/% +3))) + num-children (|> r.nat (:: @ map (n/% 3))) children' (r.list num-children gen-tree) - #let [size' (list/fold n/+ +0 (list/map product.left children')) + #let [size' (list/fold n/+ 0 (list/map product.left children')) children (list/map product.right children')]] (wrap [(inc size') (&.branch value children)])) )))) (context: "Trees" - (<| (times +100) + (<| (times 100) (do @ [[size sample] gen-tree #let [(^open "&/.") (&.Equivalence<Tree> number.Equivalence<Nat>) diff --git a/stdlib/test/test/lux/data/collection/tree/rose/zipper.lux b/stdlib/test/test/lux/data/collection/tree/rose/zipper.lux index 8ac987570..b1481518b 100644 --- a/stdlib/test/test/lux/data/collection/tree/rose/zipper.lux +++ b/stdlib/test/test/lux/data/collection/tree/rose/zipper.lux @@ -22,7 +22,7 @@ (r.rec (function (_ gen-tree) (do r.Monad<Random> ## Each branch can have, at most, 1 child. - [size (|> r.nat (:: @ map (n/% +2)))] + [size (|> r.nat (:: @ map (n/% 2)))] (r.and r.nat (r.list size gen-tree)))))) @@ -34,7 +34,7 @@ (recur (&.next zipper))))) (context: "Zippers." - (<| (times +100) + (<| (times 100) (do @ [sample gen-tree new-val r.nat diff --git a/stdlib/test/test/lux/data/color.lux b/stdlib/test/test/lux/data/color.lux index 42d48806a..8932fad79 100644 --- a/stdlib/test/test/lux/data/color.lux +++ b/stdlib/test/test/lux/data/color.lux @@ -18,21 +18,21 @@ (-> Nat Frac) (|>> .int int-to-frac)) -(def: square (-> Frac Frac) (math.pow 2.0)) +(def: square (-> Frac Frac) (math.pow +2.0)) (def: (distance from to) (-> @.Color @.Color Frac) (let [[fr fg fb] (@.unpack from) [tr tg tb] (@.unpack to)] - (math.pow 0.5 ($_ f/+ - (|> (scale tr) (f/- (scale fr)) square) - (|> (scale tg) (f/- (scale fg)) square) - (|> (scale tb) (f/- (scale fb)) square))))) + (math.pow +0.5 ($_ f/+ + (|> (scale tr) (f/- (scale fr)) square) + (|> (scale tg) (f/- (scale fg)) square) + (|> (scale tb) (f/- (scale fb)) square))))) -(def: error-margin Frac 1.8) +(def: error-margin Frac +1.8) -(def: black @.Color (@.color [+0 +0 +0])) -(def: white @.Color (@.color [+255 +255 +255])) +(def: black @.Color (@.color [0 0 0])) +(def: white @.Color (@.color [255 255 255])) (do-template [<field>] [(def: (<field> color) @@ -45,18 +45,18 @@ ) (context: "Color." - (<| (times +100) + (<| (times 100) (do @ [any color colorful (|> color - (r.filter (function (_ color) (|> (distance color black) (f/>= 100.0)))) - (r.filter (function (_ color) (|> (distance color white) (f/>= 100.0))))) + (r.filter (function (_ color) (|> (distance color black) (f/>= +100.0)))) + (r.filter (function (_ color) (|> (distance color white) (f/>= +100.0))))) mediocre (|> color (r.filter (|>> saturation ((function (_ saturation) - (and (f/>= 0.25 saturation) - (f/<= 0.75 saturation))))))) - ratio (|> r.frac (r.filter (f/>= 0.5)))] + (and (f/>= +0.25 saturation) + (f/<= +0.75 saturation))))))) + ratio (|> r.frac (r.filter (f/>= +0.5)))] ($_ seq (test "Has equivalence." (:: @.Equivalence<Color> = any any)) @@ -90,7 +90,7 @@ (saturation (@.de-saturate ratio mediocre)))) (test "Can gray-scale color." (let [gray'ed (@.gray-scale mediocre)] - (and (f/= 0.0 + (and (f/= +0.0 (saturation gray'ed)) (|> (luminance gray'ed) (f/- (luminance mediocre)) diff --git a/stdlib/test/test/lux/data/error.lux b/stdlib/test/test/lux/data/error.lux index bea6146aa..30a12855d 100644 --- a/stdlib/test/test/lux/data/error.lux +++ b/stdlib/test/test/lux/data/error.lux @@ -13,9 +13,9 @@ (^open "&/.") &.Monad<Error>] ($_ seq (test "Functor correctly handles both cases." - (and (|> (: (&.Error Int) (#&.Success 10)) + (and (|> (: (&.Error Int) (#&.Success +10)) (&/map inc) - (case> (#&.Success 11) #1 _ #0)) + (case> (#&.Success +11) #1 _ #0)) (|> (: (&.Error Int) (#&.Error "YOLO")) (&/map inc) @@ -23,24 +23,24 @@ )) (test "Apply correctly handles both cases." - (and (|> (&/wrap 20) - (case> (#&.Success 20) #1 _ #0)) - (|> (&/apply (&/wrap inc) (&/wrap 10)) - (case> (#&.Success 11) #1 _ #0)) + (and (|> (&/wrap +20) + (case> (#&.Success +20) #1 _ #0)) + (|> (&/apply (&/wrap inc) (&/wrap +10)) + (case> (#&.Success +11) #1 _ #0)) (|> (&/apply (&/wrap inc) (#&.Error "YOLO")) (case> (#&.Error "YOLO") #1 _ #0)))) (test "Monad correctly handles both cases." (and (|> (do &.Monad<Error> [f (wrap i/+) - a (wrap 10) - b (wrap 20)] + a (wrap +10) + b (wrap +20)] (wrap (f a b))) - (case> (#&.Success 30) #1 _ #0)) + (case> (#&.Success +30) #1 _ #0)) (|> (do &.Monad<Error> [f (wrap i/+) a (#&.Error "YOLO") - b (wrap 20)] + b (wrap +20)] (wrap (f a b))) (case> (#&.Error "YOLO") #1 _ #0)) )) @@ -51,8 +51,8 @@ (^open "io/.") io.Monad<IO>] (test "Can add error functionality to any monad." (|> (io.run (do (&.ErrorT io.Monad<IO>) - [a (lift (io/wrap 123)) - b (wrap 456)] + [a (lift (io/wrap +123)) + b (wrap +456)] (wrap (i/+ a b)))) - (case> (#&.Success 579) #1 - _ #0))))) + (case> (#&.Success +579) #1 + _ #0))))) diff --git a/stdlib/test/test/lux/data/format/json.lux b/stdlib/test/test/lux/data/format/json.lux index 0f1f6ebce..dc30d54d7 100644 --- a/stdlib/test/test/lux/data/format/json.lux +++ b/stdlib/test/test/lux/data/format/json.lux @@ -44,18 +44,18 @@ (r.Random @.JSON) (r.rec (function (_ gen-json) (do r.Monad<Random> - [size (:: @ map (n/% +2) r.nat)] + [size (:: @ map (n/% 2) r.nat)] ($_ r.or (:: @ wrap []) r.bit - (|> r.frac (:: @ map (f/* 1_000_000.0))) + (|> r.frac (:: @ map (f/* +1_000_000.0))) (r.unicode size) (r.row size gen-json) (r.dictionary text.Hash<Text> size (r.unicode size) gen-json) ))))) (context: "JSON" - (<| (times +100) + (<| (times 100) (do @ [sample gen-json #let [(^open "@/.") @.Equivalence<JSON> @@ -113,7 +113,7 @@ (def: gen-record (r.Random Record) (do r.Monad<Random> - [size (:: @ map (n/% +2) r.nat)] + [size (:: @ map (n/% 2) r.nat)] ($_ r.and r.bit r.frac @@ -167,8 +167,8 @@ )))) (context: "Polytypism" - (<| (seed +14562075782602945288) - ## (times +100) + (<| (seed 14562075782602945288) + ## (times 100) (do @ [sample gen-record #let [(^open "@/.") Equivalence<Record> diff --git a/stdlib/test/test/lux/data/format/xml.lux b/stdlib/test/test/lux/data/format/xml.lux index e1e773a96..b61ad1a5d 100644 --- a/stdlib/test/test/lux/data/format/xml.lux +++ b/stdlib/test/test/lux/data/format/xml.lux @@ -44,22 +44,22 @@ (def: xml-identifier^ (r.Random Name) - (r.and (xml-text^ +0 +10) - (xml-text^ +1 +10))) + (r.and (xml-text^ 0 10) + (xml-text^ 1 10))) (def: gen-xml (r.Random &.XML) (r.rec (function (_ gen-xml) - (r.or (xml-text^ +1 +10) + (r.or (xml-text^ 1 10) (do r.Monad<Random> - [size (size^ +0 +2)] + [size (size^ 0 2)] ($_ r.and xml-identifier^ - (r.dictionary name.Hash<Name> size xml-identifier^ (xml-text^ +0 +10)) + (r.dictionary name.Hash<Name> size xml-identifier^ (xml-text^ 0 10)) (r.list size gen-xml))))))) (context: "XML." - (<| (times +100) + (<| (times 100) (do @ [sample gen-xml #let [(^open "&/.") &.Equivalence<XML> @@ -78,14 +78,14 @@ )))) (context: "Parsing." - (<| (times +100) + (<| (times 100) (do @ - [text (xml-text^ +1 +10) - num-children (|> r.nat (:: @ map (n/% +5))) - children (r.list num-children (xml-text^ +1 +10)) + [text (xml-text^ 1 10) + num-children (|> r.nat (:: @ map (n/% 5))) + children (r.list num-children (xml-text^ 1 10)) tag xml-identifier^ attr xml-identifier^ - value (xml-text^ +1 +10) + value (xml-text^ 1 10) #let [node (#&.Node tag (dict.put attr value &.attrs) (list/map (|>> #&.Text) children))]] diff --git a/stdlib/test/test/lux/data/lazy.lux b/stdlib/test/test/lux/data/lazy.lux index 094a1d164..b5918c281 100644 --- a/stdlib/test/test/lux/data/lazy.lux +++ b/stdlib/test/test/lux/data/lazy.lux @@ -9,7 +9,7 @@ lux/test) (context: "Lazy." - (<| (times +100) + (<| (times 100) (do @ [left r.nat right r.nat @@ -27,7 +27,7 @@ )))) (context: "Functor, Apply, Monad." - (<| (times +100) + (<| (times 100) (do @ [sample r.nat] ($_ seq diff --git a/stdlib/test/test/lux/data/maybe.lux b/stdlib/test/test/lux/data/maybe.lux index 95ee39d91..4f135b68a 100644 --- a/stdlib/test/test/lux/data/maybe.lux +++ b/stdlib/test/test/lux/data/maybe.lux @@ -49,8 +49,8 @@ (let [lift (&.lift io.Monad<IO>)] (test "Can add maybe functionality to any monad." (|> (io.run (do (&.MaybeT io.Monad<IO>) - [a (lift (io/wrap 123)) - b (wrap 456)] + [a (lift (io/wrap +123)) + b (wrap +456)] (wrap (i/+ a b)))) - (case> (#.Some 579) #1 - _ #0))))) + (case> (#.Some +579) #1 + _ #0))))) diff --git a/stdlib/test/test/lux/data/name.lux b/stdlib/test/test/lux/data/name.lux index 5c6311100..53751066d 100644 --- a/stdlib/test/test/lux/data/name.lux +++ b/stdlib/test/test/lux/data/name.lux @@ -16,17 +16,17 @@ (|> (r.unicode size) (r.filter (|>> (text.contains? ".") not)))) (context: "Names" - (<| (times +100) + (<| (times 100) (do @ [## First Name - sizeM1 (|> r.nat (:: @ map (n/% +100))) - sizeN1 (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1)))) + sizeM1 (|> r.nat (:: @ map (n/% 100))) + sizeN1 (|> r.nat (:: @ map (|>> (n/% 100) (n/max 1)))) module1 (gen-part sizeM1) short1 (gen-part sizeN1) #let [name1 [module1 short1]] ## Second Name - sizeM2 (|> r.nat (:: @ map (n/% +100))) - sizeN2 (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1)))) + sizeM2 (|> r.nat (:: @ map (n/% 100))) + sizeN2 (|> r.nat (:: @ map (|>> (n/% 100) (n/max 1)))) module2 (gen-part sizeM2) short2 (gen-part sizeN2) #let [name2 [module2 short2]] diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux index 93c0ac68d..b5cf8e414 100644 --- a/stdlib/test/test/lux/data/number.lux +++ b/stdlib/test/test/lux/data/number.lux @@ -13,7 +13,7 @@ (do-template [category rand-gen <Equivalence> <Order>] [(context: (format "[" category "] " "Equivalence & Order") - (<| (times +100) + (<| (times 100) (do @ [x rand-gen y rand-gen] @@ -30,7 +30,7 @@ (do-template [category rand-gen <Number> <Order>] [(context: (format "[" category "] " "Number") - (<| (times +100) + (<| (times 100) (do @ [x rand-gen #let [(^open ".") <Number> @@ -53,7 +53,7 @@ (do-template [category rand-gen <Enum> <Number> <Order>] [(context: (format "[" category "] " "Enum") - (<| (times +100) + (<| (times 100) (do @ [x rand-gen] (test "" (let [(^open ".") <Number> @@ -75,7 +75,7 @@ (do-template [category rand-gen <Number> <Order> <Interval> <test>] [(context: (format "[" category "] " "Interval") - (<| (times +100) + (<| (times 100) (do @ [x (|> rand-gen (r.filter <test>)) #let [(^open ".") <Number> @@ -87,12 +87,12 @@ ["Int" r.int Number<Int> Order<Int> Interval<Int> (function (_ _) #1)] ## Both min and max values will be positive (thus, greater than zero) ["Rev" r.rev Number<Rev> Order<Rev> Interval<Rev> (function (_ _) #1)] - ["Frac" r.frac Number<Frac> Order<Frac> Interval<Frac> (f/> 0.0)] + ["Frac" r.frac Number<Frac> Order<Frac> Interval<Frac> (f/> +0.0)] ) (do-template [category rand-gen <Number> <Order> <Monoid> <cap> <test>] [(context: (format "[" category "] " "Monoid") - (<| (times +100) + (<| (times 100) (do @ [x (|> rand-gen (:: @ map (|>> (:: <Number> abs) <cap>)) (r.filter <test>)) #let [(^open ".") <Number> @@ -103,27 +103,27 @@ (= x (compose x identity)) (= identity (compose identity identity)))))))] - ["Nat/Add" r.nat Number<Nat> Order<Nat> Add@Monoid<Nat> (n/% +1000) (function (_ _) #1)] - ["Nat/Mul" r.nat Number<Nat> Order<Nat> Mul@Monoid<Nat> (n/% +1000) (function (_ _) #1)] - ["Nat/Min" r.nat Number<Nat> Order<Nat> Min@Monoid<Nat> (n/% +1000) (function (_ _) #1)] - ["Nat/Max" r.nat Number<Nat> Order<Nat> Max@Monoid<Nat> (n/% +1000) (function (_ _) #1)] - ["Int/Add" r.int Number<Int> Order<Int> Add@Monoid<Int> (i/% 1000) (function (_ _) #1)] - ["Int/Mul" r.int Number<Int> Order<Int> Mul@Monoid<Int> (i/% 1000) (function (_ _) #1)] - ["Int/Min" r.int Number<Int> Order<Int> Min@Monoid<Int> (i/% 1000) (function (_ _) #1)] - ["Int/Max" r.int Number<Int> Order<Int> Max@Monoid<Int> (i/% 1000) (function (_ _) #1)] + ["Nat/Add" r.nat Number<Nat> Order<Nat> Add@Monoid<Nat> (n/% 1000) (function (_ _) #1)] + ["Nat/Mul" r.nat Number<Nat> Order<Nat> Mul@Monoid<Nat> (n/% 1000) (function (_ _) #1)] + ["Nat/Min" r.nat Number<Nat> Order<Nat> Min@Monoid<Nat> (n/% 1000) (function (_ _) #1)] + ["Nat/Max" r.nat Number<Nat> Order<Nat> Max@Monoid<Nat> (n/% 1000) (function (_ _) #1)] + ["Int/Add" r.int Number<Int> Order<Int> Add@Monoid<Int> (i/% +1000) (function (_ _) #1)] + ["Int/Mul" r.int Number<Int> Order<Int> Mul@Monoid<Int> (i/% +1000) (function (_ _) #1)] + ["Int/Min" r.int Number<Int> Order<Int> Min@Monoid<Int> (i/% +1000) (function (_ _) #1)] + ["Int/Max" r.int Number<Int> Order<Int> Max@Monoid<Int> (i/% +1000) (function (_ _) #1)] ["Rev/Add" r.rev Number<Rev> Order<Rev> Add@Monoid<Rev> (r/% .125) (function (_ _) #1)] ["Rev/Mul" r.rev Number<Rev> Order<Rev> Mul@Monoid<Rev> (r/% .125) (function (_ _) #1)] ["Rev/Min" r.rev Number<Rev> Order<Rev> Min@Monoid<Rev> (r/% .125) (function (_ _) #1)] ["Rev/Max" r.rev Number<Rev> Order<Rev> Max@Monoid<Rev> (r/% .125) (function (_ _) #1)] - ["Frac/Add" r.frac Number<Frac> Order<Frac> Add@Monoid<Frac> (f/% 1000.0) (f/> 0.0)] - ["Frac/Mul" r.frac Number<Frac> Order<Frac> Mul@Monoid<Frac> (f/% 1000.0) (f/> 0.0)] - ["Frac/Min" r.frac Number<Frac> Order<Frac> Min@Monoid<Frac> (f/% 1000.0) (f/> 0.0)] - ["Frac/Max" r.frac Number<Frac> Order<Frac> Max@Monoid<Frac> (f/% 1000.0) (f/> 0.0)] + ["Frac/Add" r.frac Number<Frac> Order<Frac> Add@Monoid<Frac> (f/% +1000.0) (f/> +0.0)] + ["Frac/Mul" r.frac Number<Frac> Order<Frac> Mul@Monoid<Frac> (f/% +1000.0) (f/> +0.0)] + ["Frac/Min" r.frac Number<Frac> Order<Frac> Min@Monoid<Frac> (f/% +1000.0) (f/> +0.0)] + ["Frac/Max" r.frac Number<Frac> Order<Frac> Max@Monoid<Frac> (f/% +1000.0) (f/> +0.0)] ) (do-template [<category> <rand-gen> <Equivalence> <Codec>] [(context: (format "[" <category> "] " "Alternative formats") - (<| (times +100) + (<| (times 100) (do @ [x <rand-gen>] (test "Can encode/decode values." @@ -158,10 +158,10 @@ ) (context: "Can convert frac values to/from their bit patterns." - (<| (times +100) + (<| (times 100) (do @ [raw r.frac - factor (|> r.nat (:: @ map (|>> (n/% +1000) (n/max +1)))) + factor (|> r.nat (:: @ map (|>> (n/% 1000) (n/max 1)))) #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)))))) @@ -169,17 +169,17 @@ (context: "Macros for alternative numeric encodings." ($_ seq (test "Binary." - (and (n/= (bin "+11001001") (bin "+11_00_10_01")) - (i/= (bin "11001001") (bin "11_00_10_01")) + (and (n/= (bin "11001001") (bin "11_00_10_01")) + (i/= (bin "+11001001") (bin "+11_00_10_01")) (r/= (bin ".11001001") (bin ".11_00_10_01")) - (f/= (bin "1100.1001") (bin "11_00.10_01")))) + (f/= (bin "+1100.1001") (bin "+11_00.10_01")))) (test "Octal." - (and (n/= (oct "+615243") (oct "+615_243")) - (i/= (oct "615243") (oct "615_243")) + (and (n/= (oct "615243") (oct "615_243")) + (i/= (oct "+615243") (oct "+615_243")) (r/= (oct ".615243") (oct ".615_243")) - (f/= (oct "6152.43") (oct "615_2.43")))) + (f/= (oct "+6152.43") (oct "+615_2.43")))) (test "Hexadecimal." - (and (n/= (hex "+deadBEEF") (hex "+dead_BEEF")) - (i/= (hex "deadBEEF") (hex "dead_BEEF")) + (and (n/= (hex "deadBEEF") (hex "dead_BEEF")) + (i/= (hex "+deadBEEF") (hex "+dead_BEEF")) (r/= (hex ".deadBEEF") (hex ".dead_BEEF")) - (f/= (hex "deadBE.EF") (hex "dead_BE.EF")))))) + (f/= (hex "+deadBE.EF") (hex "+dead_BE.EF")))))) diff --git a/stdlib/test/test/lux/data/number/complex.lux b/stdlib/test/test/lux/data/number/complex.lux index 9347b891c..537027710 100644 --- a/stdlib/test/test/lux/data/number/complex.lux +++ b/stdlib/test/test/lux/data/number/complex.lux @@ -12,7 +12,7 @@ ["r" random]]] lux/test) -(def: margin-of-error Frac 1.0e-9) +(def: margin-of-error Frac +1.0e-9) (def: (within? margin standard value) (-> Frac &.Complex &.Complex Bit) @@ -26,8 +26,8 @@ (def: gen-dim (r.Random Frac) (do r.Monad<Random> - [factor (|> r.nat (:: @ map (|>> (n/% +1000) (n/max +1)))) - measure (|> r.frac (r.filter (f/> 0.0)))] + [factor (|> r.nat (:: @ map (|>> (n/% 1000) (n/max 1)))) + measure (|> r.frac (r.filter (f/> +0.0)))] (wrap (f/* (|> factor .int int-to-frac) measure)))) @@ -39,7 +39,7 @@ (wrap (&.complex real imaginary)))) (context: "Construction" - (<| (times +100) + (<| (times 100) (do @ [real gen-dim imaginary gen-dim] @@ -55,7 +55,7 @@ )))) (context: "Absolute value" - (<| (times +100) + (<| (times 100) (do @ [real gen-dim imaginary gen-dim] @@ -78,7 +78,7 @@ )))) (context: "Addidion, substraction, multiplication and division" - (<| (times +100) + (<| (times 100) (do @ [x gen-complex y gen-complex @@ -116,13 +116,13 @@ floored (|> quotient (update@ #&.real math.floor) (update@ #&.imaginary math.floor))] - (within? 0.000000000001 + (within? +0.000000000001 x (|> quotient (&.* y) (&.+ rem))))) )))) (context: "Conjugate, reciprocal, signum, negation" - (<| (times +100) + (<| (times 100) (do @ [x gen-complex] ($_ seq @@ -141,9 +141,9 @@ (test "Absolute value of signum is always root2(2), 1 or 0." (let [signum-abs (|> x &.signum &.abs (get@ #&.real))] - (or (f/= 0.0 signum-abs) - (f/= 1.0 signum-abs) - (f/= (math.pow 0.5 2.0) signum-abs)))) + (or (f/= +0.0 signum-abs) + (f/= +1.0 signum-abs) + (f/= (math.pow +0.5 +2.0) signum-abs)))) (test "Negation is its own inverse." (let [there (&.negate x) @@ -162,11 +162,11 @@ (|> normal forward backward (within? margin-of-error normal)))) (context: "Trigonometry" - (<| (seed +17274883666004960943) - ## (times +100) + (<| (seed 17274883666004960943) + ## (times 100) (do @ - [angle (|> gen-complex (:: @ map (|>> (update@ #&.real (f/% 1.0)) - (update@ #&.imaginary (f/% 1.0)))))] + [angle (|> gen-complex (:: @ map (|>> (update@ #&.real (f/% +1.0)) + (update@ #&.imaginary (f/% +1.0)))))] ($_ seq (test "Arc-sine is the inverse of sine." (trigonometric-symmetry &.sin &.asin angle)) @@ -178,22 +178,22 @@ (trigonometric-symmetry &.tan &.atan angle)))))) (context: "Power 2 and exponential/logarithm" - (<| (times +100) + (<| (times 100) (do @ [x gen-complex] ($_ seq (test "Root 2 is inverse of power 2." - (|> x (&.pow' 2.0) (&.pow' 0.5) (within? margin-of-error x))) + (|> x (&.pow' +2.0) (&.pow' +0.5) (within? margin-of-error x))) (test "Logarithm is inverse of exponentiation." (|> x &.log &.exp (within? margin-of-error x))) )))) (context: "Complex roots" - (<| (times +100) + (<| (times 100) (do @ [sample gen-complex - degree (|> r.nat (:: @ map (|>> (n/max +1) (n/% +5))))] + degree (|> r.nat (:: @ map (|>> (n/max 1) (n/% 5))))] (test "Can calculate the N roots for any complex number." (|> sample (&.roots degree) diff --git a/stdlib/test/test/lux/data/number/i64.lux b/stdlib/test/test/lux/data/number/i64.lux index d48d009e6..62de5e56e 100644 --- a/stdlib/test/test/lux/data/number/i64.lux +++ b/stdlib/test/test/lux/data/number/i64.lux @@ -10,7 +10,7 @@ lux/test) (context: "Bitwise operations." - (<| (times +100) + (<| (times 100) (do @ [pattern r.nat idx (:: @ map (n/% &.width) r.nat)] @@ -20,10 +20,10 @@ (&.count (&.clear idx pattern))) (|> (&.count pattern) (n/- (&.count (&.clear idx pattern))) - (n/<= +1)) + (n/<= 1)) (|> (&.count (&.set idx pattern)) (n/- (&.count pattern)) - (n/<= +1)))) + (n/<= 1)))) (test "Can query whether a bit is set." (and (or (and (&.set? idx pattern) (not (&.set? idx (&.clear idx pattern)))) @@ -39,16 +39,16 @@ (n/+ (&.count pattern) (&.count (&.not pattern))))) (test "Can do simple binary logic." - (and (n/= +0 + (and (n/= 0 (&.and pattern (&.not pattern))) - (n/= (&.not +0) + (n/= (&.not 0) (&.or pattern (&.not pattern))) - (n/= (&.not +0) + (n/= (&.not 0) (&.xor pattern (&.not pattern))) - (n/= +0 + (n/= 0 (&.xor pattern pattern)))) (test "rotate-left and rotate-right are inverses of one another." @@ -69,7 +69,7 @@ (n/= pattern)))) (test "Shift right respect the sign of ints." (let [value (.int pattern)] - (if (i/< 0 value) - (i/< 0 (&.arithmetic-right-shift idx value)) - (i/>= 0 (&.arithmetic-right-shift idx value))))) + (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/number/ratio.lux b/stdlib/test/test/lux/data/number/ratio.lux index 8a2f1640d..aa931d688 100644 --- a/stdlib/test/test/lux/data/number/ratio.lux +++ b/stdlib/test/test/lux/data/number/ratio.lux @@ -12,27 +12,27 @@ (def: gen-part (r.Random Nat) - (|> r.nat (:: r.Monad<Random> map (|>> (n/% +1000) (n/max +1))))) + (|> r.nat (:: r.Monad<Random> map (|>> (n/% 1000) (n/max 1))))) (def: gen-ratio (r.Random &.Ratio) (do r.Monad<Random> [numerator gen-part denominator (|> gen-part - (r.filter (|>> (n/= +0) not)) + (r.filter (|>> (n/= 0) not)) (r.filter (|>> (n/= numerator) not)))] (wrap (&.ratio numerator denominator)))) (context: "Normalization" - (<| (times +100) + (<| (times 100) (do @ [denom1 gen-part denom2 gen-part sample gen-ratio] ($_ seq (test "All zeroes are the same." - (&.= (&.ratio +0 denom1) - (&.ratio +0 denom2))) + (&.= (&.ratio 0 denom1) + (&.ratio 0 denom2))) (test "All ratios are built normalized." (|> sample @@ -42,7 +42,7 @@ )))) (context: "Arithmetic" - (<| (times +100) + (<| (times 100) (do @ [x gen-ratio y gen-ratio @@ -67,12 +67,12 @@ (let [remainder (&.% min max) multiple (&.- remainder max) factor (&./ min multiple)] - (and (|> factor (get@ #&.denominator) (n/= +1)) + (and (|> factor (get@ #&.denominator) (n/= 1)) (|> factor (&.* min) (&.+ remainder) (&.= max))))) )))) (context: "Negation, absolute value and signum" - (<| (times +100) + (<| (times 100) (do @ [sample gen-ratio] ($_ seq @@ -90,7 +90,7 @@ )))) (context: "Order" - (<| (times +100) + (<| (times 100) (do @ [x gen-ratio y gen-ratio] @@ -103,7 +103,7 @@ )))) (context: "Codec" - (<| (times +100) + (<| (times 100) (do @ [sample gen-ratio #let [(^open "&/.") &.Codec<Text,Ratio>]] diff --git a/stdlib/test/test/lux/data/product.lux b/stdlib/test/test/lux/data/product.lux index 440ccf62c..86db80d0e 100644 --- a/stdlib/test/test/lux/data/product.lux +++ b/stdlib/test/test/lux/data/product.lux @@ -7,11 +7,11 @@ (context: "Products" ($_ seq (test "Can access the sides of a pair." - (and (i/= 1 (@.left [1 2])) - (i/= 2 (@.right [1 2])))) + (and (i/= +1 (@.left [+1 +2])) + (i/= +2 (@.right [+1 +2])))) (test "Can swap the sides of a pair." - (let [[_left _right] (@.swap [1 2])] - (and (i/= 2 _left) - (i/= 1 _right)))) + (let [[_left _right] (@.swap [+1 +2])] + (and (i/= +2 _left) + (i/= +1 _right)))) )) diff --git a/stdlib/test/test/lux/data/sum.lux b/stdlib/test/test/lux/data/sum.lux index a771a23bb..96c0518c0 100644 --- a/stdlib/test/test/lux/data/sum.lux +++ b/stdlib/test/test/lux/data/sum.lux @@ -13,25 +13,25 @@ (let [(^open "List/.") (list.Equivalence<List> text.Equivalence<Text>)] ($_ seq (test "Can inject values into Either." - (and (|> (left "Hello") (case> (+0 "Hello") #1 _ #0)) - (|> (right "World") (case> (+1 "World") #1 _ #0)))) + (and (|> (left "Hello") (case> (0 "Hello") #1 _ #0)) + (|> (right "World") (case> (1 "World") #1 _ #0)))) (test "Can discriminate eithers based on their cases." (let [[_lefts _rights] (partition (: (List (| Text Text)) - (list (+0 "0") (+1 "1") (+0 "2"))))] + (list (0 "+0") (1 "+1") (0 "+2"))))] (and (List/= _lefts (lefts (: (List (| Text Text)) - (list (+0 "0") (+1 "1") (+0 "2"))))) + (list (0 "+0") (1 "+1") (0 "+2"))))) (List/= _rights (rights (: (List (| Text Text)) - (list (+0 "0") (+1 "1") (+0 "2")))))))) + (list (0 "+0") (1 "+1") (0 "+2")))))))) (test "Can apply a function to an Either value depending on the case." - (and (i/= 10 (either (function (_ _) 10) - (function (_ _) 20) - (: (| Text Text) (+0 "")))) - (i/= 20 (either (function (_ _) 10) - (function (_ _) 20) - (: (| Text Text) (+1 "")))))) + (and (i/= +10 (either (function (_ _) +10) + (function (_ _) +20) + (: (| Text Text) (0 "")))) + (i/= +20 (either (function (_ _) +10) + (function (_ _) +20) + (: (| Text Text) (1 "")))))) ))) diff --git a/stdlib/test/test/lux/data/text.lux b/stdlib/test/test/lux/data/text.lux index e4982cab7..a98eb92e6 100644 --- a/stdlib/test/test/lux/data/text.lux +++ b/stdlib/test/test/lux/data/text.lux @@ -13,21 +13,21 @@ lux/test) (context: "Size" - (<| (times +100) + (<| (times 100) (do @ - [size (:: @ map (n/% +100) r.nat) + [size (:: @ map (n/% 100) r.nat) sample (r.unicode size)] - (test "" (or (and (n/= +0 size) + (test "" (or (and (n/= 0 size) (&.empty? sample)) (n/= size (&.size sample))))))) (def: bounded-size (r.Random Nat) (|> r.nat - (:: r.Monad<Random> map (|>> (n/% +20) (n/+ +1))))) + (:: r.Monad<Random> map (|>> (n/% 20) (n/+ 1))))) (context: "Locations" - (<| (times +100) + (<| (times 100) (do @ [size bounded-size idx (:: @ map (n/% size) r.nat) @@ -56,7 +56,7 @@ )))) (context: "Text functions" - (<| (times +100) + (<| (times 100) (do @ [sizeL bounded-size sizeR bounded-size @@ -83,10 +83,10 @@ _ #0)) - (|> [(&.clip +0 sizeL sample) + (|> [(&.clip 0 sizeL sample) (&.clip sizeL (&.size sample) sample) (&.clip' sizeL sample) - (&.clip' +0 sample)] + (&.clip' 0 sample)] (case> [(#.Right _l) (#.Right _r) (#.Right _r') (#.Right _f)] (and (= sampleL _l) (= sampleR _r) @@ -99,16 +99,16 @@ )))) (context: "More text functions" - (<| (times +100) + (<| (times 100) (do @ [sizeP bounded-size sizeL bounded-size #let [## The wider unicode charset includes control characters that ## can make text replacement work improperly. ## Because of that, I restrict the charset. - normal-char-gen (|> r.nat (:: @ map (|>> (n/% +128) (n/max +1))))] - sep1 (r.text normal-char-gen +1) - sep2 (r.text normal-char-gen +1) + normal-char-gen (|> r.nat (:: @ map (|>> (n/% 128) (n/max 1))))] + sep1 (r.text normal-char-gen 1) + sep2 (r.text normal-char-gen 1) #let [part-gen (|> (r.text normal-char-gen sizeP) (r.filter (|>> (&.contains? sep1) not)))] parts (r.list sizeL part-gen) diff --git a/stdlib/test/test/lux/data/text/format.lux b/stdlib/test/test/lux/data/text/format.lux index a66a579b6..bd66712a8 100644 --- a/stdlib/test/test/lux/data/text/format.lux +++ b/stdlib/test/test/lux/data/text/format.lux @@ -12,10 +12,10 @@ ($_ seq (test "Can format common values simply." (and (&/= "#1" (%b #1)) - (&/= "+123" (%n +123)) - (&/= "123" (%i 123)) - (&/= "123.456" (%f 123.456)) + (&/= "123" (%n 123)) + (&/= "+123" (%i +123)) + (&/= "+123.456" (%f +123.456)) (&/= ".5" (%r .5)) (&/= "\"YOLO\"" (%t "YOLO")) - (&/= "User-id: 123 -- Active: #1" (format "User-id: " (%i 123) " -- Active: " (%b #1))))) + (&/= "User-id: +123 -- Active: #1" (format "User-id: " (%i +123) " -- Active: " (%b #1))))) ))) diff --git a/stdlib/test/test/lux/data/text/lexer.lux b/stdlib/test/test/lux/data/text/lexer.lux index 9654c29e6..d87f91eb4 100644 --- a/stdlib/test/test/lux/data/text/lexer.lux +++ b/stdlib/test/test/lux/data/text/lexer.lux @@ -73,9 +73,9 @@ )) (context: "Literals" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) + [size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 10)))) sample (r.unicode size) non-sample (|> (r.unicode size) (r.filter (|>> (text/= sample) not)))] diff --git a/stdlib/test/test/lux/data/text/regex.lux b/stdlib/test/test/lux/data/text/regex.lux index 2b9a5b9df..96f56c3d9 100644 --- a/stdlib/test/test/lux/data/text/regex.lux +++ b/stdlib/test/test/lux/data/text/regex.lux @@ -252,26 +252,26 @@ (context: "Regular Expressions [Alternation]" ($_ seq (test "Can specify alternative patterns." - (and (should-check ["a" (+0 [])] (&.regex "a|b") "a") - (should-check ["b" (+1 [])] (&.regex "a|b") "b") + (and (should-check ["a" (0 [])] (&.regex "a|b") "a") + (should-check ["b" (1 [])] (&.regex "a|b") "b") (should-fail (&.regex "a|b") "c"))) (test "Can have groups within alternations." - (and (should-check ["abc" (+0 ["b" "c"])] (&.regex "a(.)(.)|b(.)(.)") "abc") - (should-check ["bcd" (+1 ["c" "d"])] (&.regex "a(.)(.)|b(.)(.)") "bcd") + (and (should-check ["abc" (0 ["b" "c"])] (&.regex "a(.)(.)|b(.)(.)") "abc") + (should-check ["bcd" (1 ["c" "d"])] (&.regex "a(.)(.)|b(.)(.)") "bcd") (should-fail (&.regex "a(.)(.)|b(.)(.)") "cde") - (should-check ["809-345-6789" (+0 ["809" "345-6789" "345" "6789"])] + (should-check ["809-345-6789" (0 ["809" "345-6789" "345" "6789"])] (&.regex "(\\d{3})-((\\d{3})-(\\d{4}))|b(.)d") "809-345-6789"))) )) (context: "Pattern-matching" - (<| (times +100) + (<| (times 100) (do @ - [sample1 (r.unicode +3) - sample2 (r.unicode +3) - sample3 (r.unicode +4)] + [sample1 (r.unicode 3) + sample2 (r.unicode 3) + sample3 (r.unicode 4)] (case (format sample1 "-" sample2 "-" sample3) (&.^regex "(.{3})-(.{3})-(.{4})" [_ match1 match2 match3]) diff --git a/stdlib/test/test/lux/host.js.lux b/stdlib/test/test/lux/host.js.lux index cba72d0ae..faf9f6b5f 100644 --- a/stdlib/test/test/lux/host.js.lux +++ b/stdlib/test/test/lux/host.js.lux @@ -21,8 +21,8 @@ (is? "BAR"))) (test "Can call JavaScript functions" - (and (is? 124.0 - (&.call! (&.ref "Math.ceil" &.Function) [123.45] Frac)) - (is? 124.0 - (&.call! (&.ref "Math") "ceil" [123.45] Frac)))) + (and (is? +124.0 + (&.call! (&.ref "Math.ceil" &.Function) [+123.45] Frac)) + (is? +124.0 + (&.call! (&.ref "Math") "ceil" [+123.45] Frac)))) )) diff --git a/stdlib/test/test/lux/host.jvm.lux b/stdlib/test/test/lux/host.jvm.lux index 400f786b0..49a229d11 100644 --- a/stdlib/test/test/lux/host.jvm.lux +++ b/stdlib/test/test/lux/host.jvm.lux @@ -59,7 +59,7 @@ ([] foo [boolean String] void #throws [Exception])) (context: "Conversions" - (<| (times +100) + (<| (times 100) (do @ [sample r.int] (with-expansions @@ -108,9 +108,9 @@ )) (context: "Arrays" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +1)))) + [size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 1)))) idx (|> r.nat (:: @ map (n/% size))) value r.int] ($_ seq diff --git a/stdlib/test/test/lux/io.lux b/stdlib/test/test/lux/io.lux index 1cef1097d..66cd4a730 100644 --- a/stdlib/test/test/lux/io.lux +++ b/stdlib/test/test/lux/io.lux @@ -12,13 +12,13 @@ (context: "I/O" ($_ seq (test "" (text/= "YOLO" (&.run (&.io "YOLO")))) - (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>] - (&/apply (&/wrap (i/+ 10)) (&/wrap 20)))))) - (test "" (i/= 30 (&.run (do &.Monad<IO> - [f (wrap i/+) - x (wrap 10) - y (wrap 20)] - (wrap (f x y)))))))) + (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>] + (&/apply (&/wrap (i/+ +10)) (&/wrap +20)))))) + (test "" (i/= +30 (&.run (do &.Monad<IO> + [f (wrap i/+) + x (wrap +10) + y (wrap +20)] + (wrap (f x y)))))))) diff --git a/stdlib/test/test/lux/macro/code.lux b/stdlib/test/test/lux/macro/code.lux index d4739c894..1e0d4a606 100644 --- a/stdlib/test/test/lux/macro/code.lux +++ b/stdlib/test/test/lux/macro/code.lux @@ -18,17 +18,17 @@ (and (text/= <text> (&.to-text <expr>)) (:: &.Equivalence<Code> = <expr> <expr>)))] - [(&.bit #1) "#1"] - [(&.bit #0) "#0"] - [(&.int 123) "123"] - [(&.frac 123.0) "123.0"] - [(&.text "\n") "\"\\n\""] - [(&.tag ["yolo" "lol"]) "#yolo.lol"] - [(&.identifier ["yolo" "lol"]) "yolo.lol"] - [(&.form (list (&.bit #1) (&.int 123))) "(#1 123)"] - [(&.tuple (list (&.bit #1) (&.int 123))) "[#1 123]"] - [(&.record (list [(&.bit #1) (&.int 123)])) "{#1 123}"] - [(&.local-tag "lol") "#lol"] - [(&.local-identifier "lol") "lol"] + [(&.bit #1) "#1"] + [(&.bit #0) "#0"] + [(&.int +123) "+123"] + [(&.frac +123.0) "+123.0"] + [(&.text "\n") "\"\\n\""] + [(&.tag ["yolo" "lol"]) "#yolo.lol"] + [(&.identifier ["yolo" "lol"]) "yolo.lol"] + [(&.form (list (&.bit #1) (&.int +123))) "(#1 +123)"] + [(&.tuple (list (&.bit #1) (&.int +123))) "[#1 +123]"] + [(&.record (list [(&.bit #1) (&.int +123)])) "{#1 +123}"] + [(&.local-tag "lol") "#lol"] + [(&.local-identifier "lol") "lol"] )] ($_ seq <tests>))) diff --git a/stdlib/test/test/lux/macro/poly/equivalence.lux b/stdlib/test/test/lux/macro/poly/equivalence.lux index 40dae030c..8b10dc738 100644 --- a/stdlib/test/test/lux/macro/poly/equivalence.lux +++ b/stdlib/test/test/lux/macro/poly/equivalence.lux @@ -48,8 +48,8 @@ (def: gen-record (r.Random Record) (do r.Monad<Random> - [size (:: @ map (n/% +2) r.nat) - #let [gen-int (|> r.int (:: @ map (|>> int/abs (i/% 1_000_000))))]] + [size (:: @ map (n/% 2) r.nat) + #let [gen-int (|> r.int (:: @ map (|>> int/abs (i/% +1_000_000))))]] ($_ r.and r.bit gen-int @@ -65,7 +65,7 @@ ## [Tests] (context: "Equivalence polytypism" - (<| (times +100) + (<| (times 100) (do @ [sample gen-record #let [(^open "&/.") Equivalence<Record>]] diff --git a/stdlib/test/test/lux/macro/syntax.lux b/stdlib/test/test/lux/macro/syntax.lux index 155f7985a..b1e2f445b 100644 --- a/stdlib/test/test/lux/macro/syntax.lux +++ b/stdlib/test/test/lux/macro/syntax.lux @@ -73,10 +73,10 @@ (enforced? (s.this (<ctor> <value>)) (list (<ctor> <value>)))))] ["Can parse Bit syntax." #1 code.bit bit.Equivalence<Bit> s.bit] - ["Can parse Nat syntax." +123 code.nat number.Equivalence<Nat> s.nat] - ["Can parse Int syntax." 123 code.int number.Equivalence<Int> s.int] + ["Can parse Nat syntax." 123 code.nat number.Equivalence<Nat> s.nat] + ["Can parse Int syntax." +123 code.int number.Equivalence<Int> s.int] ["Can parse Rev syntax." .123 code.rev number.Equivalence<Rev> s.rev] - ["Can parse Frac syntax." 123.0 code.frac number.Equivalence<Frac> s.frac] + ["Can parse Frac syntax." +123.0 code.frac number.Equivalence<Frac> s.frac] ["Can parse Text syntax." "\n" code.text text.Equivalence<Text> s.text] ["Can parse Identifier syntax." ["yolo" "lol"] code.identifier name.Equivalence<Name> s.identifier] ["Can parse Tag syntax." ["yolo" "lol"] code.tag name.Equivalence<Name> s.tag] @@ -103,21 +103,21 @@ (with-expansions [<group-tests> (do-template [<type> <parser> <ctor>] [(test (format "Can parse " <type> " syntax.") - (and (match [#1 123] - (p.run (list (<ctor> (list (code.bit #1) (code.int 123)))) + (and (match [#1 +123] + (p.run (list (<ctor> (list (code.bit #1) (code.int +123)))) (<parser> (p.and s.bit s.int)))) (match #1 (p.run (list (<ctor> (list (code.bit #1)))) (<parser> s.bit))) - (fails? (p.run (list (<ctor> (list (code.bit #1) (code.int 123)))) + (fails? (p.run (list (<ctor> (list (code.bit #1) (code.int +123)))) (<parser> s.bit))) (match (#.Left #1) (p.run (list (<ctor> (list (code.bit #1)))) (<parser> (p.or s.bit s.int)))) - (match (#.Right 123) - (p.run (list (<ctor> (list (code.int 123)))) + (match (#.Right +123) + (p.run (list (<ctor> (list (code.int +123)))) (<parser> (p.or s.bit s.int)))) - (fails? (p.run (list (<ctor> (list (code.frac 123.0)))) + (fails? (p.run (list (<ctor> (list (code.frac +123.0)))) (<parser> (p.or s.bit s.int))))))] ["form" s.form code.form] @@ -126,8 +126,8 @@ <group-tests> (test "Can parse record syntax." - (match [#1 123] - (p.run (list (code.record (list [(code.bit #1) (code.int 123)]))) + (match [#1 +123] + (p.run (list (code.record (list [(code.bit #1) (code.int +123)]))) (s.record (p.and s.bit s.int))))) ))) @@ -135,7 +135,7 @@ ($_ seq (test "Can parse any Code." (match [_ (#.Bit #1)] - (p.run (list (code.bit #1) (code.int 123)) + (p.run (list (code.bit #1) (code.int +123)) s.any))) (test "Can check whether the end has been reached." diff --git a/stdlib/test/test/lux/math.lux b/stdlib/test/test/lux/math.lux index c20a89c60..4cdb8eed5 100644 --- a/stdlib/test/test/lux/math.lux +++ b/stdlib/test/test/lux/math.lux @@ -14,7 +14,7 @@ (f/< margin-of-error (frac/abs (f/- standard value)))) -(def: margin Frac 0.0000001) +(def: margin Frac +0.0000001) (def: (trigonometric-symmetry forward backward angle) (-> (-> Frac Frac) (-> Frac Frac) Frac Bit) @@ -22,7 +22,7 @@ (|> normal forward backward (within? margin normal)))) (context: "Trigonometry" - (<| (times +100) + (<| (times 100) (do @ [angle (|> r.frac (:: @ map (f/* &.tau)))] ($_ seq @@ -37,57 +37,57 @@ )))) (context: "Rounding" - (<| (times +100) + (<| (times 100) (do @ - [sample (|> r.frac (:: @ map (f/* 1000.0)))] + [sample (|> r.frac (:: @ map (f/* +1000.0)))] ($_ seq (test "The ceiling will be an integer value, and will be >= the original." (let [ceil'd (&.ceil sample)] (and (|> ceil'd frac-to-int int-to-frac (f/= ceil'd)) (f/>= sample ceil'd) - (f/<= 1.0 (f/- sample ceil'd))))) + (f/<= +1.0 (f/- sample ceil'd))))) (test "The floor will be an integer value, and will be <= the original." (let [floor'd (&.floor sample)] (and (|> floor'd frac-to-int int-to-frac (f/= floor'd)) (f/<= sample floor'd) - (f/<= 1.0 (f/- floor'd sample))))) + (f/<= +1.0 (f/- floor'd sample))))) (test "The round will be an integer value, and will be < or > or = the original." (let [round'd (&.round sample)] (and (|> round'd frac-to-int int-to-frac (f/= round'd)) - (f/<= 1.0 (frac/abs (f/- sample round'd)))))) + (f/<= +1.0 (frac/abs (f/- sample round'd)))))) )))) (context: "Exponentials and logarithms" - (<| (times +100) + (<| (times 100) (do @ - [sample (|> r.frac (:: @ map (f/* 10.0)))] + [sample (|> r.frac (:: @ map (f/* +10.0)))] (test "Logarithm is the inverse of exponential." - (|> sample &.exp &.log (within? 1.0e-15 sample)))))) + (|> sample &.exp &.log (within? +1.0e-15 sample)))))) (context: "Greatest-Common-Divisor and Least-Common-Multiple" - (<| (times +100) + (<| (times 100) (do @ - [#let [gen-nat (|> r.nat (:: @ map (|>> (n/% +1000) (n/max +1))))] + [#let [gen-nat (|> r.nat (:: @ map (|>> (n/% 1000) (n/max 1))))] x gen-nat y gen-nat] ($_ seq (test "GCD" (let [gcd (&.n/gcd x y)] - (and (n/= +0 (n/% gcd x)) - (n/= +0 (n/% gcd y)) - (n/>= +1 gcd)))) + (and (n/= 0 (n/% gcd x)) + (n/= 0 (n/% gcd y)) + (n/>= 1 gcd)))) (test "LCM" (let [lcm (&.n/lcm x y)] - (and (n/= +0 (n/% x lcm)) - (n/= +0 (n/% y lcm)) + (and (n/= 0 (n/% x lcm)) + (n/= 0 (n/% y lcm)) (n/<= (n/* x y) lcm)))) )))) (context: "Infix syntax" - (<| (times +100) + (<| (times 100) (do @ [x r.nat y r.nat @@ -109,8 +109,8 @@ (&.infix [&.sin theta]))) (test "Can use regular syntax in the middle of infix code." - (n/= (&.n/gcd +450 (n/* +3 +9)) - (&.infix [(n/* +3 +9) &.n/gcd +450]))) + (n/= (&.n/gcd 450 (n/* 3 9)) + (&.infix [(n/* 3 9) &.n/gcd 450]))) (test "Can use non-numerical functions/macros as operators." (bit/= (and (n/< y x) (n/< z y)) diff --git a/stdlib/test/test/lux/math/logic/continuous.lux b/stdlib/test/test/lux/math/logic/continuous.lux index c53ad434b..b9db253f6 100644 --- a/stdlib/test/test/lux/math/logic/continuous.lux +++ b/stdlib/test/test/lux/math/logic/continuous.lux @@ -9,7 +9,7 @@ lux/test) (context: "Operations" - (<| (times +100) + (<| (times 100) (do @ [left r.rev right r.rev] diff --git a/stdlib/test/test/lux/math/logic/fuzzy.lux b/stdlib/test/test/lux/math/logic/fuzzy.lux index 585857883..fe36a58c5 100644 --- a/stdlib/test/test/lux/math/logic/fuzzy.lux +++ b/stdlib/test/test/lux/math/logic/fuzzy.lux @@ -19,9 +19,9 @@ (do-template [<desc> <hash> <gen> <triangle> <lt> <lte> <gt> <gte>] [(context: (format "[" <desc> "] " "Triangles") - (<| (times +100) + (<| (times 100) (do @ - [values (r.set <hash> +3 <gen>) + [values (r.set <hash> 3 <gen>) #let [[x y z] (case (set.to-list values) (^ (list x y z)) [x y z] @@ -60,9 +60,9 @@ (do-template [<desc> <hash> <gen> <trapezoid> <lt> <lte> <gt> <gte>] [(context: (format "[" <desc> "] " "Trapezoids") - (<| (times +100) + (<| (times 100) (do @ - [values (r.set <hash> +4 <gen>) + [values (r.set <hash> 4 <gen>) #let [[w x y z] (case (set.to-list values) (^ (list w x y z)) [w x y z] @@ -114,7 +114,7 @@ (wrap (&.triangle x y z)))) (context: "Combinators" - (<| (times +100) + (<| (times 100) (do @ [left gen-triangle right gen-triangle @@ -148,10 +148,10 @@ )))) (context: "From predicates and sets" - (<| (times +100) + (<| (times 100) (do @ - [#let [set-10 (set.from-list number.Hash<Nat> (list.n/range +0 +10))] - sample (|> r.nat (:: @ map (n/% +20)))] + [#let [set-10 (set.from-list number.Hash<Nat> (list.n/range 0 10))] + sample (|> r.nat (:: @ map (n/% 20)))] ($_ seq (test "Values that satisfy a predicate have membership = 1. Values that don't have membership = 0." @@ -165,7 +165,7 @@ )))) (context: "Thresholds" - (<| (times +100) + (<| (times 100) (do @ [fuzzy gen-triangle sample r.rev diff --git a/stdlib/test/test/lux/math/modular.lux b/stdlib/test/test/lux/math/modular.lux index ad9fda295..559928304 100644 --- a/stdlib/test/test/lux/math/modular.lux +++ b/stdlib/test/test/lux/math/modular.lux @@ -14,18 +14,18 @@ [type ("type/." Equivalence<Type>)]] lux/test) -(def: %3 (/.modulus 3)) +(def: %3 (/.modulus +3)) (`` (type: Mod3 (~~ (:of %3)))) (def: modulusR (r.Random Int) (|> r.int - (:: r.Monad<Random> map (i/% 1000)) - (r.filter (|>> (i/= 0) not)))) + (:: r.Monad<Random> map (i/% +1000)) + (r.filter (|>> (i/= +0) not)))) (def: valueR (r.Random Int) - (|> r.int (:: r.Monad<Random> map (i/% 1000)))) + (|> r.int (:: r.Monad<Random> map (i/% +1000)))) (def: (modR modulus) (All [m] (-> (/.Modulus m) (r.Random [Int (/.Mod m)]))) @@ -60,7 +60,7 @@ (/.m/= (m/! param subject))))) (context: "Modular arithmetic." - (<| (times +100) + (<| (times 100) (do @ [_normalM modulusR _alternativeM (|> modulusR (r.filter (|>> (i/= _normalM) not))) @@ -109,7 +109,7 @@ (#.Some subject^-1) (|> subject (/.m/* subject^-1) - (/.m/= (/.mod normalM 1))) + (/.m/= (/.mod normalM +1))) #.None #1)) diff --git a/stdlib/test/test/lux/math/random.lux b/stdlib/test/test/lux/math/random.lux index 24f95bd30..f3f118c90 100644 --- a/stdlib/test/test/lux/math/random.lux +++ b/stdlib/test/test/lux/math/random.lux @@ -17,9 +17,9 @@ lux/test) (context: "Random." - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) + [size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 10)))) _list (r.list size r.nat) _row (r.row size r.nat) _array (r.array size r.nat) diff --git a/stdlib/test/test/lux/time/date.lux b/stdlib/test/test/lux/time/date.lux index ecccbc034..602ecc78f 100644 --- a/stdlib/test/test/lux/time/date.lux +++ b/stdlib/test/test/lux/time/date.lux @@ -30,7 +30,7 @@ (random/wrap #@.December)))))) (context: "(Month) Equivalence." - (<| (times +100) + (<| (times 100) (do @ [sample month #let [(^open "@/.") @.Equivalence<Month>]] @@ -38,7 +38,7 @@ (@/= sample sample))))) (context: "(Month) Order." - (<| (times +100) + (<| (times 100) (do @ [reference month sample month @@ -50,7 +50,7 @@ (@/<= reference sample))))))) (context: "(Month) Enum." - (<| (times +100) + (<| (times 100) (do @ [sample month #let [(^open "@/.") @.Enum<Month>]] @@ -73,7 +73,7 @@ (random/wrap #@.Saturday)))) (context: "(Day) Equivalence." - (<| (times +100) + (<| (times 100) (do @ [sample day #let [(^open "@/.") @.Equivalence<Day>]] @@ -81,7 +81,7 @@ (@/= sample sample))))) (context: "(Day) Order." - (<| (times +100) + (<| (times 100) (do @ [reference day sample day @@ -93,7 +93,7 @@ (@/<= reference sample))))))) (context: "(Day) Enum." - (<| (times +100) + (<| (times 100) (do @ [sample day #let [(^open "@/.") @.Enum<Day>]] @@ -110,7 +110,7 @@ (|> _instant.instant (:: r.Monad<Random> map @instant.date))) (context: "(Date) Equivalence." - (<| (times +100) + (<| (times 100) (do @ [sample date #let [(^open "@/.") @.Equivalence<Date>]] @@ -118,7 +118,7 @@ (@/= sample sample))))) (context: "(Date) Order." - (<| (times +100) + (<| (times 100) (do @ [reference date sample date @@ -130,8 +130,8 @@ (@/<= reference sample))))))) (context: "(Date) Codec" - (<| (seed +6623983470548808292) - ## (times +100) + (<| (seed 6623983470548808292) + ## (times 100) (do @ [sample date #let [(^open "@/.") @.Equivalence<Date> diff --git a/stdlib/test/test/lux/time/duration.lux b/stdlib/test/test/lux/time/duration.lux index 199eabe24..1231fb563 100644 --- a/stdlib/test/test/lux/time/duration.lux +++ b/stdlib/test/test/lux/time/duration.lux @@ -16,14 +16,14 @@ (|> r.int (:: r.Monad<Random> map @.from-millis))) (context: "Conversion." - (<| (times +100) + (<| (times 100) (do @ [millis r.int] (test "Can convert from/to milliseconds." (|> millis @.from-millis @.to-millis (i/= millis)))))) (context: "Equivalence." - (<| (times +100) + (<| (times 100) (do @ [sample duration #let [(^open "@/.") @.Equivalence<Duration>]] @@ -31,7 +31,7 @@ (@/= sample sample))))) (context: "Order." - (<| (times +100) + (<| (times 100) (do @ [reference duration sample duration @@ -43,17 +43,17 @@ (@/<= reference sample))))))) (context: "Arithmetic." - (<| (times +100) + (<| (times 100) (do @ [sample (|> duration (:: @ map (@.frame @.day))) frame duration - factor (|> r.int (:: @ map (|>> (i/% 10) (i/max 1)))) + factor (|> r.int (:: @ map (|>> (i/% +10) (i/max +1)))) #let [(^open "@/.") @.Order<Duration>]] ($_ seq (test "Can scale a duration." (|> sample (@.scale factor) (@.query sample) (i/= factor))) (test "Scaling a duration by one does not change it." - (|> sample (@.scale 1) (@/= sample))) + (|> sample (@.scale +1) (@/= sample))) (test "Merging with the empty duration changes nothing." (|> sample (@.merge @.empty) (@/= sample))) (test "Merging a duration with it's opposite yields an empty duration." @@ -74,7 +74,7 @@ frame)))))))))) (context: "Codec" - (<| (times +100) + (<| (times 100) (do @ [sample duration #let [(^open "@/.") @.Equivalence<Duration> diff --git a/stdlib/test/test/lux/time/instant.lux b/stdlib/test/test/lux/time/instant.lux index 40902fa03..734456765 100644 --- a/stdlib/test/test/lux/time/instant.lux +++ b/stdlib/test/test/lux/time/instant.lux @@ -18,21 +18,21 @@ [// ["_." duration]]) -(def: boundary Int 99_999_999_999_999) +(def: boundary Int +99_999_999_999_999) (def: #export instant (r.Random @.Instant) (|> r.int (:: r.Monad<Random> map (|>> (i/% boundary) @.from-millis)))) (context: "Conversion." - (<| (times +100) + (<| (times 100) (do @ [millis r.int] (test "Can convert from/to milliseconds." (|> millis @.from-millis @.to-millis (i/= millis)))))) (context: "Equivalence." - (<| (times +100) + (<| (times 100) (do @ [sample instant #let [(^open "@/.") @.Equivalence<Instant>]] @@ -40,7 +40,7 @@ (@/= sample sample))))) (context: "Order" - (<| (times +100) + (<| (times 100) (do @ [reference instant sample instant @@ -52,7 +52,7 @@ (@/<= reference sample))))))) (context: "Enum" - (<| (times +100) + (<| (times 100) (do @ [sample instant #let [(^open "@/.") @.Enum<Instant>]] @@ -65,7 +65,7 @@ (|> sample @/pred @/succ (@/= sample))))))) (context: "Arithmetic" - (<| (times +100) + (<| (times 100) (do @ [sample instant span _duration.duration @@ -82,8 +82,8 @@ (|> @.epoch (@.shift (@.relative sample)) (@/= sample))))))) ## (context: "Codec" -## (<| (seed +9863552679229274604) -## ## (times +100) +## (<| (seed 9863552679229274604) +## ## (times 100) ## (do @ ## [sample instant ## #let [(^open "@/.") @.Equivalence<Instant> diff --git a/stdlib/test/test/lux/type.lux b/stdlib/test/test/lux/type.lux index 1c950eb40..e8de83c56 100644 --- a/stdlib/test/test/lux/type.lux +++ b/stdlib/test/test/lux/type.lux @@ -18,7 +18,7 @@ (def: #export gen-short (r.Random Text) (do r.Monad<Random> - [size (|> r.nat (:: @ map (n/% +10)))] + [size (|> r.nat (:: @ map (n/% 10)))] (r.unicode size))) (def: #export gen-name @@ -48,7 +48,7 @@ ## [Tests] (context: "Types" - (<| (times +100) + (<| (times 100) (do @ [sample gen-type] (test "Every type is equal to itself." @@ -84,9 +84,9 @@ (&.un-name aliased))))))) (context: "Type construction [structs]" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (n/% +3))) + [size (|> r.nat (:: @ map (n/% 3))) members (|> gen-type (r.filter (function (_ type) (case type @@ -115,9 +115,9 @@ ))))) (context: "Type construction [parameterized]" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (n/% +3))) + [size (|> r.nat (:: @ map (n/% 3))) members (M.seq @ (list.repeat size gen-type)) extra (|> gen-type (r.filter (function (_ type) @@ -141,9 +141,9 @@ )))) (context: "Type construction [higher order]" - (<| (times +100) + (<| (times 100) (do @ - [size (|> r.nat (:: @ map (n/% +3))) + [size (|> r.nat (:: @ map (n/% 3))) extra (|> gen-type (r.filter (function (_ type) (case type diff --git a/stdlib/test/test/lux/type/check.lux b/stdlib/test/test/lux/type/check.lux index b801c1cd5..c5700f8cb 100644 --- a/stdlib/test/test/lux/type/check.lux +++ b/stdlib/test/test/lux/type/check.lux @@ -50,7 +50,7 @@ ## [Tests] (context: "Any and Nothing." - (<| (times +100) + (<| (times 100) (do @ [sample (|> //.gen-type (r.filter valid-type?))] ($_ seq @@ -98,7 +98,7 @@ )) (context: "Type application." - (<| (times +100) + (<| (times 100) (do @ [meta //.gen-type data //.gen-type] @@ -109,7 +109,7 @@ (|> Ann (#.Apply meta) (#.Apply data)))))))) (context: "Primitive types." - (<| (times +100) + (<| (times 100) (do @ [nameL //.gen-short nameR (|> //.gen-short (r.filter (|>> (text/= nameL) not))) @@ -177,9 +177,9 @@ (wrap [[head-id head-type] ids+types [tail-id tail-type]]))) (context: "Rings of type variables." - (<| (times +100) + (<| (times 100) (do @ - [num-connections (|> r.nat (:: @ map (n/% +100))) + [num-connections (|> r.nat (:: @ map (n/% 100))) boundT (|> //.gen-type (r.filter (|>> (case> (#.Var _) #0 _ #1)))) pick-pcg (r.and r.nat r.nat)] ($_ seq @@ -227,7 +227,7 @@ headRR-post (@.ring head-idR)] (@.assert "" (let [same-rings? (:: set.Equivalence<Set> = headRL-post headRR-post) - expected-size? (n/= (n/* +2 (inc num-connections)) + expected-size? (n/= (n/* 2 (inc num-connections)) (set.size headRL-post)) union? (:: set.Equivalence<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 8bb1d0d48..669d720c2 100644 --- a/stdlib/test/test/lux/type/implicit.lux +++ b/stdlib/test/test/lux/type/implicit.lux @@ -15,7 +15,7 @@ lux/test) (context: "Automatic structure selection" - (<| (times +100) + (<| (times 100) (do @ [x r.nat y r.nat] @@ -24,17 +24,17 @@ (let [(^open "list/.") (list.Equivalence<List> number.Equivalence<Nat>)] (and (bit/= (:: number.Equivalence<Nat> = x y) (::: = x y)) - (list/= (list.n/range +1 +10) - (::: map inc (list.n/range +0 +9))) + (list/= (list.n/range 1 10) + (::: map inc (list.n/range 0 9))) ))) (test "Can automatically select second-order structures." (::: = - (list.n/range +1 +10) - (list.n/range +1 +10))) + (list.n/range 1 10) + (list.n/range 1 10))) (test "Can automatically select third-order structures." - (let [lln (::: map (list.n/range +1) - (list.n/range +1 +10))] + (let [lln (::: map (list.n/range 1) + (list.n/range 1 10))] (::: = lln lln))) )))) diff --git a/stdlib/test/test/lux/type/resource.lux b/stdlib/test/test/lux/type/resource.lux index 1457135a6..cf6d49b17 100644 --- a/stdlib/test/test/lux/type/resource.lux +++ b/stdlib/test/test/lux/type/resource.lux @@ -11,37 +11,37 @@ (context: "Sub-structural typing." ($_ seq (test "Can produce and consume keys in an ordered manner." - (<| (n/= (n/+ +123 +456)) + (<| (n/= (n/+ 123 456)) io.run resource.run-sync (do resource.IxMonad<Sync> - [res|left (resource.ordered-sync +123) - res|right (resource.ordered-sync +456) + [res|left (resource.ordered-sync 123) + res|right (resource.ordered-sync 456) right (resource.read-sync res|right) left (resource.read-sync res|left)] (wrap (n/+ left right))))) (test "Can exchange commutative keys." - (<| (n/= (n/+ +123 +456)) + (<| (n/= (n/+ 123 456)) io.run resource.run-sync (do resource.IxMonad<Sync> - [res|left (resource.commutative-sync +123) - res|right (resource.commutative-sync +456) - _ (resource.exchange-sync [+1 +0]) + [res|left (resource.commutative-sync 123) + res|right (resource.commutative-sync 456) + _ (resource.exchange-sync [1 0]) left (resource.read-sync res|left) right (resource.read-sync res|right)] (wrap (n/+ left right))))) (test "Can group and un-group keys." - (<| (n/= (n/+ +123 +456)) + (<| (n/= (n/+ 123 456)) io.run resource.run-sync (do resource.IxMonad<Sync> - [res|left (resource.commutative-sync +123) - res|right (resource.commutative-sync +456) - _ (resource.group-sync +2) - _ (resource.un-group-sync +2) + [res|left (resource.commutative-sync 123) + res|right (resource.commutative-sync 456) + _ (resource.group-sync 2) + _ (resource.un-group-sync 2) right (resource.read-sync res|right) left (resource.read-sync res|left)] (wrap (n/+ left right))))) diff --git a/stdlib/test/test/lux/world/binary.lux b/stdlib/test/test/lux/world/binary.lux index acc3161c1..a6a6df9d6 100644 --- a/stdlib/test/test/lux/world/binary.lux +++ b/stdlib/test/test/lux/world/binary.lux @@ -30,7 +30,7 @@ (def: #export (binary size) (-> Nat (r.Random /.Binary)) (let [output (/.create size)] - (loop [idx +0] + (loop [idx 0] (if (n/< size idx) (do r.Monad<Random> [byte r.nat] @@ -40,19 +40,19 @@ (def: (bits-io bytes read write value) (-> Nat (-> Nat /.Binary (e.Error Nat)) (-> Nat Nat /.Binary (e.Error Any)) Nat Bit) - (let [binary (/.create +8) - bits (n/* +8 bytes) - capped-value (|> +1 (i64.left-shift bits) dec (i64.and value))] + (let [binary (/.create 8) + bits (n/* 8 bytes) + capped-value (|> 1 (i64.left-shift bits) dec (i64.and value))] (succeed (do e.Monad<Error> - [_ (write +0 value binary) - output (read +0 binary)] + [_ (write 0 value binary) + output (read 0 binary)] (wrap (n/= capped-value output)))))) (context: "Binary." - (<| (times +100) + (<| (times 100) (do @ - [#let [gen-size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +8))))] + [#let [gen-size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 8))))] binary-size gen-size random-binary (binary binary-size) value r.nat @@ -65,17 +65,17 @@ (test "Can get size of binary." (|> random-binary /.size (n/= binary-size))) (test "Can read/write 8-bit values." - (bits-io +1 /.read/8 /.write/8 value)) + (bits-io 1 /.read/8 /.write/8 value)) (test "Can read/write 16-bit values." - (bits-io +2 /.read/16 /.write/16 value)) + (bits-io 2 /.read/16 /.write/16 value)) (test "Can read/write 32-bit values." - (bits-io +4 /.read/32 /.write/32 value)) + (bits-io 4 /.read/32 /.write/32 value)) (test "Can read/write 64-bit values." - (bits-io +8 /.read/64 /.write/64 value)) + (bits-io 8 /.read/64 /.write/64 value)) (test "Can slice binaries." (let [slice-size (|> to (n/- from) inc) random-slice (e.assume (/.slice from to random-binary)) - idxs (list.n/range +0 (dec slice-size)) + idxs (list.n/range 0 (dec slice-size)) reader (function (_ binary idx) (/.read/8 idx binary))] (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 54a5e0e2a..b9bd2457a 100644 --- a/stdlib/test/test/lux/world/file.lux +++ b/stdlib/test/test/lux/world/file.lux @@ -23,11 +23,11 @@ ["_." binary]]) (def: truncate-millis - (|>> (i// 1_000) (i/* 1_000))) + (|>> (i// +1_000) (i/* +1_000))) (context: "File system." (do @ - [file-size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) + [file-size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 10)))) dataL (_binary.binary file-size) dataR (_binary.binary file-size) code r.nat @@ -37,7 +37,7 @@ instant.absolute)))] ($_ seq (wrap (do promise.Monad<Promise> - [#let [file (format "temp_file_" (%n (n/+ +0 code)))] + [#let [file (format "temp_file_" (%n (n/+ 0 code)))] result (promise.future (do (:: @.JVM@System &monad) [pre! (@.exists? @.JVM@System file) @@ -50,7 +50,7 @@ (assert "Can create/delete files." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [file (format "temp_file_" (%n (n/+ +1 code)))] + [#let [file (format "temp_file_" (%n (n/+ 1 code)))] result (promise.future (do (:: @.JVM@System &monad) [_ (:: @.JVM@System write dataL file) @@ -60,7 +60,7 @@ (assert "Can write/read files." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [file (format "temp_file_" (%n (n/+ +2 code)))] + [#let [file (format "temp_file_" (%n (n/+ 2 code)))] result (promise.future (do (:: @.JVM@System &monad) [_ (:: @.JVM@System write dataL file) @@ -70,7 +70,7 @@ (assert "Can read file size." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [file (format "temp_file_" (%n (n/+ +3 code)))] + [#let [file (format "temp_file_" (%n (n/+ 3 code)))] result (promise.future (do (:: @.JVM@System &monad) [_ (:: @.JVM@System write dataL file) @@ -78,13 +78,13 @@ output (:: @.JVM@System read file) read-size (:: @.JVM@System size file) _ (:: @.JVM@System delete file)] - (wrap (and (n/= (n/* +2 file-size) read-size) - (:: binary.Equivalence<Binary> = dataL (error.assume (binary.slice +0 (dec file-size) output))) + (wrap (and (n/= (n/* 2 file-size) read-size) + (:: binary.Equivalence<Binary> = dataL (error.assume (binary.slice 0 (dec file-size) output))) (:: binary.Equivalence<Binary> = dataR (error.assume (binary.slice file-size (dec read-size) output)))))))] (assert "Can append to files." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [dir (format "temp_dir_" (%n (n/+ +4 code)))] + [#let [dir (format "temp_dir_" (%n (n/+ 4 code)))] result (promise.future (do (:: @.JVM@System &monad) [pre! (@.exists? @.JVM@System dir) @@ -97,8 +97,8 @@ (assert "Can create/delete directories." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [file (format "temp_file_" (%n (n/+ +5 code))) - dir (format "temp_dir_" (%n (n/+ +5 code)))] + [#let [file (format "temp_file_" (%n (n/+ 5 code))) + dir (format "temp_dir_" (%n (n/+ 5 code)))] result (promise.future (do (:: @.JVM@System &monad) [_ (:: @.JVM@System write dataL file) @@ -114,8 +114,8 @@ (assert "Can differentiate files from directories." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [file (format "temp_file_" (%n (n/+ +6 code))) - dir (format "temp_dir_" (%n (n/+ +6 code)))] + [#let [file (format "temp_file_" (%n (n/+ 6 code))) + dir (format "temp_dir_" (%n (n/+ 6 code)))] result (promise.future (do (:: @.JVM@System &monad) [_ (:: @.JVM@System make-directory dir) @@ -128,8 +128,8 @@ (assert "Can create files inside of directories." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [file (format "temp_file_" (%n (n/+ +7 code))) - dir (format "temp_dir_" (%n (n/+ +7 code)))] + [#let [file (format "temp_file_" (%n (n/+ 7 code))) + dir (format "temp_dir_" (%n (n/+ 7 code)))] result (promise.future (do (:: @.JVM@System &monad) [_ (:: @.JVM@System make-directory dir) @@ -147,7 +147,7 @@ (assert "Can list files inside a directory." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [file (format "temp_file_" (%n (n/+ +8 code)))] + [#let [file (format "temp_file_" (%n (n/+ 8 code)))] result (promise.future (do (:: @.JVM@System &monad) [_ (:: @.JVM@System write dataL file) @@ -158,8 +158,8 @@ (assert "Can change the time of last modification." (error.default #0 result)))) (wrap (do promise.Monad<Promise> - [#let [file0 (format "temp_file_" (%n (n/+ +9 code)) "0") - file1 (format "temp_file_" (%n (n/+ +9 code)) "1")] + [#let [file0 (format "temp_file_" (%n (n/+ 9 code)) "+0") + file1 (format "temp_file_" (%n (n/+ 9 code)) "+1")] result (promise.future (do (:: @.JVM@System &monad) [_ (:: @.JVM@System write dataL file0) diff --git a/stdlib/test/test/lux/world/net/tcp.lux b/stdlib/test/test/lux/world/net/tcp.lux index 1991e33cd..7520a2fbc 100644 --- a/stdlib/test/test/lux/world/net/tcp.lux +++ b/stdlib/test/test/lux/world/net/tcp.lux @@ -27,13 +27,13 @@ (r.Random net.Port) (|> r.nat (:: r.Monad<Random> map - (|>> (n/% +1000) - (n/+ +8000))))) + (|>> (n/% 1000) + (n/+ 8000))))) (context: "TCP networking." (do @ [port ..port - size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) + size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 10)))) from (_binary.binary size) to (_binary.binary size) #let [temp-from (binary.create size) @@ -46,18 +46,18 @@ (P.promise #.Nil)) _ (frp/map (function (_ socket) (do @ - [bytes-from (@.read temp-from +0 size socket) + [bytes-from (@.read temp-from 0 size socket) #let [_ (io.run (P.resolve (#E.Success (and (n/= size bytes-from) (:: binary.Equivalence<Binary> = from temp-from))) from-worked?))]] - (@.write to +0 size socket))) + (@.write to 0 size socket))) server)] client (@.client localhost port) - _ (@.write from +0 size client) + _ (@.write from 0 size client) from-worked? from-worked? #################### - bytes-to (@.read temp-to +0 size client) + bytes-to (@.read temp-to 0 size client) #let [to-worked? (and (n/= size bytes-to) (:: binary.Equivalence<Binary> = to temp-to))] #################### diff --git a/stdlib/test/test/lux/world/net/udp.lux b/stdlib/test/test/lux/world/net/udp.lux index b3911aea3..497cef8f3 100644 --- a/stdlib/test/test/lux/world/net/udp.lux +++ b/stdlib/test/test/lux/world/net/udp.lux @@ -24,13 +24,13 @@ (r.Random net.Port) (|> r.nat (:: r.Monad<Random> map - (|>> (n/% +1000) - (n/+ +8000))))) + (|>> (n/% 1000) + (n/+ 8000))))) (context: "UDP networking." (do @ [port ..port - size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) + size (|> r.nat (:: @ map (|>> (n/% 100) (n/max 10)))) from (_binary.binary size) to (_binary.binary size) #let [temp (binary.create size)]] @@ -40,13 +40,13 @@ [server (@.server port) client (@.client []) #################### - _ (@.write localhost port from +0 size client) - [bytes-from from-address from-port] (@.read temp +0 size server) + _ (@.write localhost port from 0 size client) + [bytes-from from-address from-port] (@.read temp 0 size server) #let [from-worked? (and (n/= size bytes-from) (:: binary.Equivalence<Binary> = from temp))] #################### - _ (@.write from-address from-port to +0 size server) - [bytes-to to-address to-port] (@.read temp +0 size client) + _ (@.write from-address from-port to 0 size server) + [bytes-to to-address to-port] (@.read temp 0 size client) #let [to-worked? (and (n/= size bytes-to) (:: binary.Equivalence<Binary> = to temp) (n/= port to-port))] |