From dff8878c13610ae8d1207aaabefbecc88cd3911f Mon Sep 17 00:00:00 2001
From: Eduardo Julian
Date: Sat, 28 Jul 2018 13:36:49 -0400
Subject: Temporary commit to get rid of "+" signs for Nat.
---
stdlib/source/lux.lux | 592 ++++++++++-----------
stdlib/source/lux/compiler/default/cache.lux | 2 +-
stdlib/source/lux/compiler/default/init.lux | 12 +-
stdlib/source/lux/compiler/default/name.lux | 2 +-
.../source/lux/compiler/default/phase/analysis.lux | 14 +-
.../default/phase/analysis/case/coverage.lux | 4 +-
.../compiler/default/phase/analysis/inference.lux | 12 +-
.../lux/compiler/default/phase/analysis/scope.lux | 6 +-
.../compiler/default/phase/analysis/structure.lux | 2 +-
.../default/phase/extension/analysis/common.lux | 10 +-
.../default/phase/extension/analysis/host.jvm.lux | 50 +-
.../lux/compiler/default/phase/synthesis.lux | 4 +-
.../default/phase/synthesis/expression.lux | 6 +-
.../compiler/default/phase/synthesis/function.lux | 10 +-
.../lux/compiler/default/phase/synthesis/loop.lux | 2 +-
.../lux/compiler/default/phase/translation.lux | 6 +-
.../translation/scheme/extension/common.jvm.lux | 18 +-
.../phase/translation/scheme/function.jvm.lux | 4 +-
.../phase/translation/scheme/runtime.jvm.lux | 8 +-
stdlib/source/lux/compiler/default/reference.lux | 8 +-
stdlib/source/lux/compiler/default/repl/type.lux | 2 +-
stdlib/source/lux/compiler/default/syntax.lux | 40 +-
stdlib/source/lux/compiler/meta/io/archive.lux | 2 +-
stdlib/source/lux/concurrency/actor.lux | 4 +-
stdlib/source/lux/concurrency/promise.lux | 2 +-
stdlib/source/lux/concurrency/semaphore.lux | 16 +-
stdlib/source/lux/control/comonad.lux | 4 +-
stdlib/source/lux/control/concatenative.lux | 22 +-
stdlib/source/lux/control/equivalence.lux | 4 +-
stdlib/source/lux/control/exception.lux | 2 +-
stdlib/source/lux/control/monad.lux | 6 +-
stdlib/source/lux/control/parser.lux | 8 +-
stdlib/source/lux/control/pipe.lux | 2 +-
stdlib/source/lux/control/writer.lux | 2 +-
stdlib/source/lux/data/bit.lux | 4 +-
stdlib/source/lux/data/collection/array.lux | 30 +-
stdlib/source/lux/data/collection/bits.lux | 28 +-
stdlib/source/lux/data/collection/dictionary.lux | 48 +-
.../lux/data/collection/dictionary/ordered.lux | 2 +-
stdlib/source/lux/data/collection/list.lux | 74 +--
.../source/lux/data/collection/queue/priority.lux | 4 +-
stdlib/source/lux/data/collection/row.lux | 56 +-
stdlib/source/lux/data/collection/sequence.lux | 4 +-
stdlib/source/lux/data/collection/set.lux | 4 +-
stdlib/source/lux/data/collection/set/multi.lux | 22 +-
.../lux/data/collection/tree/rose/zipper.lux | 8 +-
stdlib/source/lux/data/color.lux | 20 +-
stdlib/source/lux/data/format/binary.lux | 36 +-
stdlib/source/lux/data/number.lux | 320 +++++------
stdlib/source/lux/data/number/complex.lux | 4 +-
stdlib/source/lux/data/number/i64.lux | 22 +-
stdlib/source/lux/data/number/ratio.lux | 8 +-
stdlib/source/lux/data/sum.lux | 20 +-
stdlib/source/lux/data/text.lux | 18 +-
stdlib/source/lux/data/text/buffer.lux | 4 +-
stdlib/source/lux/data/text/lexer.lux | 4 +-
stdlib/source/lux/data/text/regex.lux | 14 +-
stdlib/source/lux/data/text/unicode.lux | 246 ++++-----
stdlib/source/lux/host.jvm.lux | 6 +-
stdlib/source/lux/io.lux | 2 +-
stdlib/source/lux/macro/code.lux | 2 +-
stdlib/source/lux/macro/poly.lux | 36 +-
stdlib/source/lux/macro/poly/equivalence.lux | 2 +-
stdlib/source/lux/macro/poly/functor.lux | 8 +-
stdlib/source/lux/macro/poly/json.lux | 10 +-
stdlib/source/lux/math.lux | 8 +-
stdlib/source/lux/math/random.lux | 34 +-
stdlib/source/lux/test.lux | 24 +-
stdlib/source/lux/time/date.lux | 50 +-
stdlib/source/lux/time/instant.lux | 20 +-
stdlib/source/lux/type.lux | 6 +-
stdlib/source/lux/type/check.lux | 6 +-
stdlib/source/lux/type/implicit.lux | 10 +-
stdlib/source/lux/type/resource.lux | 2 +-
stdlib/source/lux/world/binary.lux | 70 +--
stdlib/source/lux/world/net/udp.jvm.lux | 4 +-
76 files changed, 1094 insertions(+), 1094 deletions(-)
(limited to 'stdlib/source')
diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index a9c442462..a30c03a78 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -1,168 +1,168 @@
("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"
+ (|10 ["lux" "List"]
+ (|7 (|0)
+ (|1 ## "lux.Nil"
Any
## "lux.Cons"
- (+2 (+4 +1)
- (+9 (+4 +1) (+4 +0))))))
+ (|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).")]]
+ (|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.")]]
+ (|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).
-
- They start at zero (+0) and extend in the positive direction.")]]
+ (|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))))])
("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.")]]
+ (|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))))])
("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.")]]
+ (|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.")]]
+ (|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))))])
@@ -171,23 +171,23 @@
## #None
## (#Some a))
("lux def" Maybe
- (+10 ["lux" "Maybe"]
- (+7 #Nil
- (+1 ## "lux.None"
+ (|10 ["lux" "Maybe"]
+ (|7 #Nil
+ (|1 ## "lux.None"
Any
## "lux.Some"
- (+4 +1))))
+ (|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.")]]
+ (|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
@@ -204,59 +204,59 @@
## (#Named Name Type)
## )
("lux def" Type
- (+10 ["lux" "Type"]
+ (|10 ["lux" "Type"]
({Type
({Type-List
({Type-Pair
- (+9 Nothing
- (+7 #Nil
- (+1 ## "lux.Primitive"
- (+2 Text Type-List)
- (+1 ## "lux.Sum"
+ (|9 Nothing
+ (|7 #Nil
+ (|1 ## "lux.Primitive"
+ (|2 Text Type-List)
+ (|1 ## "lux.Sum"
Type-Pair
- (+1 ## "lux.Product"
+ (|1 ## "lux.Product"
Type-Pair
- (+1 ## "lux.Function"
+ (|1 ## "lux.Function"
Type-Pair
- (+1 ## "lux.Parameter"
+ (|1 ## "lux.Parameter"
Nat
- (+1 ## "lux.Var"
+ (|1 ## "lux.Var"
Nat
- (+1 ## "lux.Ex"
+ (|1 ## "lux.Ex"
Nat
- (+1 ## "lux.UnivQ"
- (+2 Type-List Type)
- (+1 ## "lux.ExQ"
- (+2 Type-List Type)
- (+1 ## "lux.Apply"
+ (|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)))))
+ (|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")]
+ (|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)]]
+ (#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
@@ -267,17 +267,17 @@
(#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")]
+ (|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)]]
+ (#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)
@@ -287,21 +287,21 @@
(#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")]
+ (|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)]]
+ (#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)
@@ -346,29 +346,29 @@
))))))))))
)}
("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")]
+ (|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)]]
+ (#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
@@ -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
@@ -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])
@@ -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)
@@ -2366,12 +2366,12 @@
(-> Nat Nat Nat)
(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,17 +2452,17 @@
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)
@@ -2471,13 +2471,13 @@
(-> Rev Rev Rev)
(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)]
+ [|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)
+ (if (n/= |0 input)
(text/compose "+" output)
- (recur (n// +10 input)
- (text/compose (|> input (n/% +10) digit-to-text)
+ (recur (n// |10 input)
+ (text/compose (|> input (n/% |10) digit-to-text)
output)))))]
(loop value ""))}
value))
@@ -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"])
@@ -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')))))))
@@ -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']
@@ -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)
@@ -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.
@@ -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."]
@@ -5715,7 +5715,7 @@
(-> <type> Bit)
(not (<even> n)))]
- [Nat n/even? n/odd? n/% n/= +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)
@@ -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
@@ -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))
@@ -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)
@@ -6170,7 +6170,7 @@
(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))
@@ -6184,7 +6184,7 @@
(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..1e264ec08 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..4972e75c5 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..34bcf41eb 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..ff540cded 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..716c11bf1 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..1676c0cf7 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..6b6896674 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..26a91dff6 100644
--- a/stdlib/source/lux/compiler/default/phase/analysis/structure.lux
+++ b/stdlib/source/lux/compiler/default/phase/analysis/structure.lux
@@ -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..d5ff4a085 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..9e4cd2e7e 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..28392eafd 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..0ab38afac 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..b7dd22f70 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..4bae596c3 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..ec67565d6 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..10a893f09 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)
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..437c92520 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,8 +70,8 @@
(_.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)]))
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..a2c9e31da 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)])
diff --git a/stdlib/source/lux/compiler/default/reference.lux b/stdlib/source/lux/compiler/default/reference.lux
index 086c72810..1c94c0349 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..e6d25a76a 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..b5e9acb51 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)]
+ [code (l.between |1 |4 l.hexadecimal)]
(wrap (case (|> code (format "+") (:: number.Hex@Codec<Text,Nat> decode))
(#.Right value)
- [(n/+ +2 (text.size code)) (text.from-code value)]
+ [(n/+ |2 (text.size code)) (text.from-code value)]
_
(undefined))))
@@ -251,7 +251,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)]])))
@@ -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..27c7416f0 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..da76351c4 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..6e2450068 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..5b1688048 100644
--- a/stdlib/source/lux/concurrency/semaphore.lux
+++ b/stdlib/source/lux/concurrency/semaphore.lux
@@ -33,7 +33,7 @@
[state (atom.read semaphore)
#let [[ready? state'] (: [Bit State]
(case (get@ #open-positions state)
- +0 [#0 (update@ #waiting-list (|>> (#.Cons signal))
+ |0 [#0 (update@ #waiting-list (|>> (#.Cons signal))
state)]
_ [#1 (update@ #open-positions dec
state)]))]
@@ -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..ef262762f 100644
--- a/stdlib/source/lux/control/comonad.lux
+++ b/stdlib/source/lux/control/comonad.lux
@@ -26,7 +26,7 @@
[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."
@@ -36,7 +36,7 @@
(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..47c3ea4ca 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/equivalence.lux b/stdlib/source/lux/control/equivalence.lux
index dea0e3fa6..5f9ca37b6 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..66c7ebf7b 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..e3196faf5 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..48119eaa5 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..716304479 100644
--- a/stdlib/source/lux/control/pipe.lux
+++ b/stdlib/source/lux/control/pipe.lux
@@ -16,7 +16,7 @@
(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)
diff --git a/stdlib/source/lux/control/writer.lux b/stdlib/source/lux/control/writer.lux
index a93242297..fc964537c 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..8b61d8b32 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..588c5132b 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..5caec8eb7 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..64c577946 100644
--- a/stdlib/source/lux/data/collection/dictionary.lux
+++ b/stdlib/source/lux/data/collection/dictionary.lux
@@ -41,7 +41,7 @@
## the appropriate multiple of the branching-exponent.
## A shift of 0 means root level.
## A shift of (* branching-exponent 1) means level 2.
-## A shift of (* branching-exponent N) means level N+1.
+## A shift of (* branching-exponent N) means level N|1.
(type: Level Nat)
## Nodes for the tree data-structure that organizes the data inside
@@ -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,7 +234,7 @@
[(set-bit-position (->bit-position idx) bitmap)
(array.write insertion-idx (#.Left sub-node) base)]])
)))
- [+0 [clean-bitmap
+ [|0 [clean-bitmap
(array.new (dec h-size))]]
(list.indices (array.size h-array)))))
@@ -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,13 +505,13 @@
(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')
+ (array/fold n/+ |0 (array/map (function (_ sub-node')
(case sub-node'
(#.Left sub-node) (size' sub-node)
- (#.Right _) +1))
+ (#.Right _) |1))
base))
(#Collisions hash 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..38442f93d 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..d7a2145c6 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')
+ input' (n// |10 input)]
+ (if (n/= |0 input')
("lux text concat" "+" 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..a5aa7dd73 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..ddedad6c5 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,7 +338,7 @@
(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)})
diff --git a/stdlib/source/lux/data/collection/sequence.lux b/stdlib/source/lux/data/collection/sequence.lux
index 2f9cf3722..95d60b555 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)
diff --git a/stdlib/source/lux/data/collection/set.lux b/stdlib/source/lux/data/collection/set.lux
index ef39c98e0..cab4105b0 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..91fd7f675 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/zipper.lux b/stdlib/source/lux/data/collection/tree/rose/zipper.lux
index 4181bd406..b732f87b2 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..c708e8775 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))
@@ -155,9 +155,9 @@
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))]
+ 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)])))
@@ -180,7 +180,7 @@
(def: #export (from-cmyk [cyan magenta yellow key])
(-> [Frac Frac Frac Frac] Color)
(if (f/= 1.0 key)
- (color [+0 +0 +0])
+ (color [|0 |0 |0])
(let [red (|> (|> 1.0 (f/- cyan))
(f/* (|> 1.0 (f/- key))))
green (|> (|> 1.0 (f/- magenta))
@@ -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>]
@@ -283,7 +283,7 @@
(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))
+ (|> (list.n/range |0 (dec results))
(list/map (|>> .int int-to-frac
(f/* slice)
(f/+ brightness)
diff --git a/stdlib/source/lux/data/format/binary.lux b/stdlib/source/lux/data/format/binary.lux
index b2feda2c5..c5c7cbb89 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/number.lux b/stdlib/source/lux/data/number.lux
index cb71b5b07..9934af3de 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -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>]
@@ -107,10 +107,10 @@
(def: top <top>)
(def: bottom <bottom>))]
- [ Nat Enum<Nat> (:coerce Nat -1) +0]
+ [ 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,8 +118,8 @@
(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/+]
@@ -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,17 +299,17 @@
(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')
+ ("lux text concat" "|" 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/>= |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)
@@ -325,10 +325,10 @@
(#e.Error ("lux text concat" <error> repr)))
(#e.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: "]
+ [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: "]
)
(do-template [<struct> <base> <to-character> <to-value> <error>]
@@ -351,14 +351,14 @@
(def: (decode repr)
(let [input-size ("lux text size" repr)]
- (if (n/>= +1 input-size)
- (let [sign (case (get-char repr +0)
+ (if (n/>= |1 input-size)
+ (let [sign (case (get-char repr |0)
(^ (#.Some "-"))
-1
_
1)]
- (loop [idx (if (i/= -1 sign) +1 +0)
+ (loop [idx (if (i/= -1 sign) |1 |0)
output 0]
(if (n/< input-size idx)
(let [digit (maybe.assume (get-char repr idx))]
@@ -380,17 +380,17 @@
(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,10 +399,10 @@
(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)))
+ [(:: <nat> decode ("lux text concat" "|" (de-prefix repr)))
(#e.Success output)])
(#e.Success (:coerce Rev output))
@@ -410,9 +410,9 @@
(#e.Error ("lux text concat" <error> repr)))
(#e.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>]
@@ -435,9 +435,9 @@
("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)]
@@ -448,7 +448,7 @@
1.0)
div-power (loop [muls-left ("lux text size" decimal-part)
output 1.0]
- (if (n/= +0 muls-left)
+ (if (n/= |0 muls-left)
output
(recur (dec muls-left)
(f/* <base> output))))
@@ -483,7 +483,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 +575,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 +597,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 +610,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,15 +622,15 @@
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)
+ (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" ".")
@@ -670,8 +670,8 @@
(def: (underscore-prefixed? number)
(-> Text Bit)
- (case ("lux text index" number "_" +0)
- (#.Some +0)
+ (case ("lux text index" number "_" |0)
+ (#.Some |0)
#1
_
@@ -740,7 +740,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,22 +753,22 @@
(def: (digits-times-5! idx output)
(-> Nat Digits Digits)
(loop [idx idx
- carry +0
+ carry |0
output output]
(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))]
+ (digits-put power |1))]
(if (i/>= 0 (:coerce Int times))
(recur (dec times)
(digits-times-5! power output))
@@ -781,7 +781,7 @@
output ""]
(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,7 +796,7 @@
(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))
(let [raw ($_ n/+
@@ -804,19 +804,19 @@
(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 +828,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,11 +842,11 @@
(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)
@@ -861,7 +861,7 @@
(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 [])]
@@ -878,21 +878,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)
@@ -913,58 +913,58 @@
(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)]
(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))
## Make it int-equivalent
(f/* ("lux math pow" 2.0 52.0)))
- sign-bit (if (f/= -1.0 sign) +1 +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,15 +972,15 @@
(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)
+ (and (n/= |0 E) (n/= |0 M))
+ (if (n/= |0 S)
0.0
(f/* -1.0 0.0))
@@ -993,7 +993,7 @@
("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..41e074be6 100644
--- a/stdlib/source/lux/data/number/complex.lux
+++ b/stdlib/source/lux/data/number/complex.lux
@@ -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-phi (|> input argument (f// r-nth))
slice (|> math.pi (f/* 2.0) (f// r-nth))]
- (|> (list.n/range +0 (dec 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..9d1e8794b 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..b072a808a 100644
--- a/stdlib/source/lux/data/number/ratio.lux
+++ b/stdlib/source/lux/data/number/ratio.lux
@@ -123,14 +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))
+ (|>> nat/encode (text.split |1) maybe.assume product.right))
(def: part-decode
(-> Text (E.Error Nat))
@@ -158,5 +158,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..24704c3c0 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..f5462e4e7 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..af9d14efc 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..14afb4254 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..3cb65dd14 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^
@@ -289,7 +289,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!
@@ -304,7 +304,7 @@
parts)]]
(wrap [(if capturing?
(list.size names)
- +0)
+ |0)
(` (do p.Monad<Parser>
[(~ (' #let)) [(~ g!total) ""]
(~+ (|> steps list.reverse list/join))]
@@ -320,12 +320,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 +347,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..96f16052a 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.jvm.lux b/stdlib/source/lux/host.jvm.lux
index cd0eaafed..767a4976f 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..ed277b4c3 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..0de1e5772 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..9be5a2ad4 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..6f356c060 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..711179404 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..b9710773a 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..124320ce9 100644
--- a/stdlib/source/lux/math.lux
+++ b/stdlib/source/lux/math.lux
@@ -88,9 +88,9 @@
(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)))))
@@ -118,7 +118,7 @@
(|> a (</> (<gcd> a b)) (<*> b))
))]
- [Nat n/mod n/gcd n/lcm +0 n/* n// n/-]
+ [Nat n/mod n/gcd n/lcm |0 n/* n// n/-]
[Int i/mod i/gcd i/lcm 0 i/* i// i/-]
)
@@ -251,7 +251,7 @@
(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/random.lux b/stdlib/source/lux/math/random.lux
index 340cb1baa..1fc5c5476 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..f9ea42c2e 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
@@ -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)]
@@ -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,7 +248,7 @@
list/join))]
(exec (log! ((~! success-message) (~ g!total-successes) (~ g!total-failures)))
((~! promise.future)
- ((~! io.exit) (if (n/> +0 (~ g!total-failures))
+ ((~! io.exit) (if (n/> |0 (~ g!total-failures))
1
0)))))
[])))))))))
diff --git a/stdlib/source/lux/time/date.lux b/stdlib/source/lux/time/date.lux
index ca5ea55b4..d3306f826 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>)
@@ -246,7 +246,7 @@
(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)
@@ -256,14 +256,14 @@
(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)
diff --git a/stdlib/source/lux/time/instant.lux b/stdlib/source/lux/time/instant.lux
index ea834391e..427f4883e 100644
--- a/stdlib/source/lux/time/instant.lux
+++ b/stdlib/source/lux/time/instant.lux
@@ -108,14 +108,14 @@
(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])
@@ -125,14 +125,14 @@
(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))
[current-month time-left]
[(dec current-month) (duration.merge month-duration time-left)])))
- [+11 time]
+ [|11 time]
(row.reverse months))))
(def: (pad value)
@@ -227,11 +227,11 @@
(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)))
@@ -288,7 +288,7 @@
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)))]]
diff --git a/stdlib/source/lux/type.lux b/stdlib/source/lux/type.lux
index 376d40d67..851039728 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..f09b8617b 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..fad0bfb5d 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..0912c2482 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/world/binary.lux b/stdlib/source/lux/world/binary.lux
index d89b7ae3a..0b72af60b 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..893538657 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 {}
--
cgit v1.2.3