diff options
Diffstat (limited to 'stdlib')
416 files changed, 4522 insertions, 3326 deletions
diff --git a/stdlib/commands.md b/stdlib/commands.md index ff590d8a6..00de913b2 100644 --- a/stdlib/commands.md +++ b/stdlib/commands.md @@ -9,7 +9,7 @@ cd ~/lux/stdlib/ \ cd ~/lux/stdlib/ \ && lux clean \ -&& lux auto test +&& lux with bibliotheca auto test ``` ## Deploy @@ -26,6 +26,9 @@ cd ~/lux/stdlib/ && mvn deploy:deploy-file \ -DartifactId=stdlib \ -Dversion=0.6.0-SNAPSHOT \ -Dpackaging=tar + +cd ~/lux/stdlib/ \ +&& lux install ``` ## Generate documentation @@ -60,6 +63,15 @@ cd ~/lux/stdlib/ \ && lein clean \ && lein with-profile aedifex lux build \ && mv target/program.jar aedifex.jar + +cd ~/lux/stdlib/ \ +&& lux clean \ +&& lux with aedifex auto build + +cd ~/lux/stdlib/ \ +&& lux clean \ +&& lux with aedifex build \ +&& mv target/program.jar aedifex.jar ``` ## Test @@ -68,5 +80,9 @@ cd ~/lux/stdlib/ \ cd ~/lux/stdlib/ \ && lein clean \ && lein with-profile aedifex lux auto test + +cd ~/lux/stdlib/ \ +&& lux clean \ +&& lux with aedifex auto test ``` diff --git a/stdlib/project.clj b/stdlib/project.clj index 81a7dc180..3b0ac6982 100644 --- a/stdlib/project.clj +++ b/stdlib/project.clj @@ -22,13 +22,10 @@ :source-paths ["source"] :dependencies [[com.github.luxlang/lux-bootstrapper ~version]] :profiles {:bibliotheca {:description "Standard library for the Lux programming language." - :dependencies [] :lux {:test "test/lux"}} :aedifex {:description "A build system/tool made exclusively for Lux." - :dependencies [] :lux {:program "program/aedifex" :test "test/aedifex"}} :scriptum {:description "A documentation generator for Lux code." - :dependencies [] :lux {:program "program/scriptum"}}} ) diff --git a/stdlib/project.lux b/stdlib/project.lux index de7325890..e617e015c 100644 --- a/stdlib/project.lux +++ b/stdlib/project.lux @@ -7,10 +7,17 @@ #repositories ["https://oss.sonatype.org/content/repositories/snapshots/" "https://oss.sonatype.org/service/local/staging/deploy/maven2/"] - #compiler ["com.github.luxlang" "lux-jvm" "0.6.0-SNAPSHOT" "jar"] - + #compiler ["com.github.luxlang" "lux-jvm" "0.6.0-SNAPSHOT" "jar"]} + + "bibliotheca" + {#description "Standard library for the Lux programming language." #test "test/lux"} "documentation" {#program "documentation/lux" - #test "documentation/lux"}} + #test "documentation/lux"} + + "aedifex" + {#description "A build system/tool made exclusively for Lux." + #program "program/aedifex" + #test "test/aedifex"}} diff --git a/stdlib/source/documentation/lux/abstract.lux b/stdlib/source/documentation/lux/abstract.lux index 9cc80dcac..a8c0d3b03 100644 --- a/stdlib/source/documentation/lux/abstract.lux +++ b/stdlib/source/documentation/lux/abstract.lux @@ -24,7 +24,7 @@ (.def: .public documentation (.List $.Module) - (list.joined + (list.together (list /apply.documentation /codec.documentation /comonad.documentation diff --git a/stdlib/source/documentation/lux/abstract/comonad.lux b/stdlib/source/documentation/lux/abstract/comonad.lux index f1e220593..5ae976a63 100644 --- a/stdlib/source/documentation/lux/abstract/comonad.lux +++ b/stdlib/source/documentation/lux/abstract/comonad.lux @@ -18,7 +18,7 @@ "A co-monadic parallel to the 'do' macro." [(let [square (function (_ n) (* n n))] (be comonad - [inputs (iterate inc +2)] + [inputs (iterate ++ +2)] (square (out inputs))))]) (.def: .public documentation diff --git a/stdlib/source/documentation/lux/abstract/interval.lux b/stdlib/source/documentation/lux/abstract/interval.lux index f4c57de2a..7162f9ee9 100644 --- a/stdlib/source/documentation/lux/abstract/interval.lux +++ b/stdlib/source/documentation/lux/abstract/interval.lux @@ -11,6 +11,10 @@ (documentation: /.Interval "A representation of top and bottom boundaries for an ordered type.") +(documentation: /.singleton + "An interval where both top and bottom are the same value." + [(singleton enum elem)]) + (documentation: /.borders? "Where a value is at the border of an interval.") @@ -31,13 +35,13 @@ ($.module /._ "" [..Interval + ..singleton ..borders? ..union ..intersection ..complement ..meets? ($.default /.between) - ($.default /.singleton) ($.default /.inner?) ($.default /.outer?) ($.default /.singleton?) diff --git a/stdlib/source/documentation/lux/abstract/monad.lux b/stdlib/source/documentation/lux/abstract/monad.lux index dd472057d..2d55ff0c5 100644 --- a/stdlib/source/documentation/lux/abstract/monad.lux +++ b/stdlib/source/documentation/lux/abstract/monad.lux @@ -21,9 +21,9 @@ z (f2 z)] (in (f3 z)))]) -(documentation: /.bind +(documentation: /.then "Apply a function with monadic effects to a monadic value and yield a new monadic value." - [(bind monad function)]) + [(then monad function)]) (documentation: /.seq "Run all the monadic values in the list and produce a list of the base values." @@ -47,7 +47,7 @@ "" [..Monad ..do - ..bind + ..then ..seq ..map ..only diff --git a/stdlib/source/documentation/lux/control.lux b/stdlib/source/documentation/lux/control.lux index 4fcbe7a98..3a1f688a9 100644 --- a/stdlib/source/documentation/lux/control.lux +++ b/stdlib/source/documentation/lux/control.lux @@ -16,30 +16,21 @@ ["#." io] ["#." lazy] ["#." maybe] - ... ["#." parser] - ... ["#." pipe] - ... ["#." reader] - ... ["#." region] - ... ["#." remember] - ... [security - ... ["#." policy] - ... ["#." capability]] - ... ["#." state] - ... ["#." thread] - ... ["#." try] - ... ["#." writer] + ["#." parser] + ["#." pipe] + ["#." reader] + ["#." region] + ["#." remember] + ["#." security] + ["#." state] + ["#." thread] + ["#." try] + ["#." writer] ]) -... (def: security -... Test -... ($_ _.and -... /policy.documentation -... /capability.documentation -... )) - (.def: .public documentation (.List $.Module) - (list.joined + (list.together (list /concatenative.documentation /concurrency.documentation /continuation.documentation @@ -48,14 +39,14 @@ /io.documentation /lazy.documentation /maybe.documentation - ... /parser.documentation - ... /pipe.documentation - ... /reader.documentation - ... /region.documentation - ... /remember.documentation - ... ..security - ... /state.documentation - ... /thread.documentation - ... /try.documentation - ... /writer.documentation + /parser.documentation + /pipe.documentation + /reader.documentation + /region.documentation + /remember.documentation + /security.documentation + /state.documentation + /thread.documentation + /try.documentation + /writer.documentation ))) diff --git a/stdlib/source/documentation/lux/control/concatenative.lux b/stdlib/source/documentation/lux/control/concatenative.lux index 495bc5512..6c97e056f 100644 --- a/stdlib/source/documentation/lux/control/concatenative.lux +++ b/stdlib/source/documentation/lux/control/concatenative.lux @@ -51,7 +51,7 @@ (documentation: /.apply "A generator for functions that turn arity N functions into arity N concatenative functions." [(: (=> [Nat] [Nat]) - ((apply 1) inc))]) + ((apply 1) ++))]) (template [<arity>] [(with_expansions [<name> (template.identifier [/._] ["apply/" <arity>]) @@ -167,7 +167,7 @@ (documentation: /.do "Do-while loop expression." - [(n.= (inc sample) + [(n.= (++ sample) (||> (push sample) (push (push false)) (push (|>> (push 1) n/+)) diff --git a/stdlib/source/documentation/lux/control/concurrency.lux b/stdlib/source/documentation/lux/control/concurrency.lux index f9b751494..1408c984a 100644 --- a/stdlib/source/documentation/lux/control/concurrency.lux +++ b/stdlib/source/documentation/lux/control/concurrency.lux @@ -18,7 +18,7 @@ (.def: .public documentation (.List $.Module) - (list.joined + (list.together (list /actor.documentation /async.documentation /atom.documentation diff --git a/stdlib/source/documentation/lux/control/concurrency/actor.lux b/stdlib/source/documentation/lux/control/concurrency/actor.lux index 29513888c..6f9327a9a 100644 --- a/stdlib/source/documentation/lux/control/concurrency/actor.lux +++ b/stdlib/source/documentation/lux/control/concurrency/actor.lux @@ -87,7 +87,7 @@ [(actor {Nat 123} ((on_mail message state self) - (message (inc state) self)))]) + (message (++ state) self)))]) (documentation: /.message: (format "A message can access the actor's state through the state parameter." diff --git a/stdlib/source/documentation/lux/control/concurrency/async.lux b/stdlib/source/documentation/lux/control/concurrency/async.lux index 2842ed06b..823967b36 100644 --- a/stdlib/source/documentation/lux/control/concurrency/async.lux +++ b/stdlib/source/documentation/lux/control/concurrency/async.lux @@ -59,17 +59,17 @@ \n "Returns an async that will eventually host its result.") [(future computation)]) -(documentation: /.delayed +(documentation: /.after "Delivers a value after a certain period has passed." - [(delayed milli_seconds value)]) + [(after milli_seconds value)]) (documentation: /.delay "An async that will be resolved after the specified amount of milli-seconds." [(delay milli_seconds)]) -(documentation: /.time_out +(documentation: /.within "Wait for an async to be resolved within the specified amount of milli-seconds." - [(time_out milli_seconds async)]) + [(within milli_seconds async)]) (.def: .public documentation (.List $.Module) @@ -87,9 +87,9 @@ ..either ..schedule! ..future - ..delayed + ..after ..delay - ..time_out + ..within ($.default /.functor) ($.default /.apply) ($.default /.monad)] diff --git a/stdlib/source/documentation/lux/control/concurrency/frp.lux b/stdlib/source/documentation/lux/control/concurrency/frp.lux index 71f740782..2500b119d 100644 --- a/stdlib/source/documentation/lux/control/concurrency/frp.lux +++ b/stdlib/source/documentation/lux/control/concurrency/frp.lux @@ -57,7 +57,7 @@ ($.default /.apply) ($.default /.monad) ($.default /.subscribe!) - ($.default /.folds) + ($.default /.aggregates) ($.default /.poll) ($.default /.periodic) ($.default /.iterations) diff --git a/stdlib/source/documentation/lux/control/exception.lux b/stdlib/source/documentation/lux/control/exception.lux index ec225630a..fae2b0163 100644 --- a/stdlib/source/documentation/lux/control/exception.lux +++ b/stdlib/source/documentation/lux/control/exception.lux @@ -63,7 +63,7 @@ (.def: .public documentation (.List $.Module) ($.module /._ - "" + "Pure-Lux exception-handling functionality." [..Exception ..match? ..when diff --git a/stdlib/source/documentation/lux/control/function.lux b/stdlib/source/documentation/lux/control/function.lux index 889cc8655..88556dda7 100644 --- a/stdlib/source/documentation/lux/control/function.lux +++ b/stdlib/source/documentation/lux/control/function.lux @@ -8,7 +8,12 @@ [macro ["." template]]]] [\\library - ["." /]]) + ["." /]] + ["." / #_ + ["#." contract] + ["#." memo] + ["#." mixin] + ["#." mutual]]) (documentation: /.identity (format "Identity function." @@ -45,4 +50,7 @@ ..flipped ..apply ($.default /.monoid)] - [])) + [/contract.documentation + /memo.documentation + /mixin.documentation + /mutual.documentation])) diff --git a/stdlib/source/documentation/lux/control/function/contract.lux b/stdlib/source/documentation/lux/control/function/contract.lux new file mode 100644 index 000000000..84ef6ad13 --- /dev/null +++ b/stdlib/source/documentation/lux/control/function/contract.lux @@ -0,0 +1,36 @@ +(.module: + [library + [lux (#- if loop) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.pre + (format "Pre-conditions." + \n "Given a test and an expression to run, only runs the expression if the test passes." + \n "Otherwise, an error is raised.") + [(pre (i.= +4 (i.+ +2 +2)) + (foo +123 +456 +789))]) + +(documentation: /.post + (format "Post-conditions." + \n "Given a predicate and an expression to run, evaluates the expression and then tests the output with the predicate." + \n "If the predicate returns #1, returns the value of the expression." + \n "Otherwise, an error is raised.") + [(post i.even? + (i.+ +2 +2))]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..pre + ..post + ($.default /.pre_condition_failed) + ($.default /.post_condition_failed)] + [])) diff --git a/stdlib/source/documentation/lux/control/function/memo.lux b/stdlib/source/documentation/lux/control/function/memo.lux new file mode 100644 index 000000000..823b49772 --- /dev/null +++ b/stdlib/source/documentation/lux/control/function/memo.lux @@ -0,0 +1,36 @@ +(.module: + [library + [lux (#- if loop) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.open + "Memoization where the memoized results can be re-used accross invocations." + [(open memo)]) + +(documentation: /.closed + (format "Memoization confined to a single invocation to the function (not counting any subsequent recursive invocations)." + \n "Memoized results will be re-used during recursive invocations, but cannot be accessed after the main invocation has ended.") + [(closed hash memo)]) + +(documentation: /.none + (format "No memoization at all." + \n "This is useful as a test control when measuring the effect of using memoization.") + [(none hash memo)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..open + ..closed + ..none + ($.default /.memoization) + ($.default /.Memo)] + [])) diff --git a/stdlib/source/documentation/lux/control/function/mixin.lux b/stdlib/source/documentation/lux/control/function/mixin.lux new file mode 100644 index 000000000..f23f065b0 --- /dev/null +++ b/stdlib/source/documentation/lux/control/function/mixin.lux @@ -0,0 +1,60 @@ +(.module: + [library + [lux (#- if loop) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Mixin + "A partially-defined function which can be mixed with others to inherit their behavior.") + +(documentation: /.mixin + "Given a mixin, produces a normal function." + [(mixin f)]) + +(documentation: /.nothing + "A mixin that does nothing and just delegates work to the next mixin.") + +(documentation: /.with + "Produces a new mixin, where the behavior of the child can make use of the behavior of the parent." + [(with parent child)]) + +(documentation: /.advice + "Only apply then mixin when the input meets some criterion." + [(advice when then)]) + +(documentation: /.before + "Executes an action before doing the main work." + [(before monad action)]) + +(documentation: /.after + "Executes an action after doing the main work." + [(after monad action)]) + +(documentation: /.Recursive + "An indirectly recursive function.") + +(documentation: /.of_recursive + "Transform an indirectly recursive function into a mixin." + [(of_recursive recursive)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Mixin + ..mixin + ..nothing + ..with + ..advice + ..before + ..after + ..Recursive + ..of_recursive + ($.default /.monoid)] + [])) diff --git a/stdlib/source/documentation/lux/control/function/mutual.lux b/stdlib/source/documentation/lux/control/function/mutual.lux new file mode 100644 index 000000000..9dd7588b7 --- /dev/null +++ b/stdlib/source/documentation/lux/control/function/mutual.lux @@ -0,0 +1,50 @@ +(.module: + [library + [lux (#- let def:) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.let + "Locally-defined mutually-recursive functions." + [(let [(even? number) + (-> Nat Bit) + (case number + 0 true + _ (odd? (-- number))) + + (odd? number) + (-> Nat Bit) + (case number + 0 false + _ (even? (-- number)))] + (and (even? 4) + (odd? 5)))]) + +(documentation: /.def: + "Globally-defined mutually-recursive functions." + [(def: + [.public (even? number) + (-> Nat Bit) + (case number + 0 true + _ (odd? (-- number)))] + + [.public (odd? number) + (-> Nat Bit) + (case number + 0 false + _ (even? (-- number)))])]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..let + ..def:] + [])) diff --git a/stdlib/source/documentation/lux/control/io.lux b/stdlib/source/documentation/lux/control/io.lux index 81cf08740..085a70314 100644 --- a/stdlib/source/documentation/lux/control/io.lux +++ b/stdlib/source/documentation/lux/control/io.lux @@ -26,7 +26,7 @@ (.def: .public documentation (.List $.Module) ($.module /._ - "" + "A method for abstracting I/O and effectful computations to make it safe while writing pure functional code." [..IO ..io ..run! diff --git a/stdlib/source/documentation/lux/control/parser.lux b/stdlib/source/documentation/lux/control/parser.lux new file mode 100644 index 000000000..081c5a792 --- /dev/null +++ b/stdlib/source/documentation/lux/control/parser.lux @@ -0,0 +1,180 @@ +(.module: + [library + [lux (#- or and not) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]] + ["." / #_ + ["#." analysis] + ["#." binary] + ["#." cli] + ["#." code] + ["#." environment] + ... ["#." json] + ... ["#." synthesis] + ... ["#." text] + ... ["#." tree] + ... ["#." type] + ... ["#." xml] + ]) + +(documentation: /.Parser + "A generic parser.") + +(documentation: /.assertion + "Fails with the given message if the test is #0." + [(assertion message test)]) + +(documentation: /.maybe + "Optionality combinator." + [(maybe parser)]) + +(documentation: /.result + (format "Executes the parser on the input." + \n "Does not verify that all of the input has been consumed by the parser." + \n "Returns both the parser's output, and a value that represents the remaining input.") + [(result parser input)]) + +(documentation: /.and + "Sequencing combinator." + [(and first second)]) + +(documentation: /.or + "Heterogeneous alternative combinator." + [(or left right)]) + +(documentation: /.either + "Homogeneous alternative combinator." + [(either this that)]) + +(documentation: /.some + "0-or-more combinator." + [(some parser)]) + +(documentation: /.many + "1-or-more combinator." + [(many parser)]) + +(documentation: /.exactly + "Parse exactly N times." + [(exactly amount parser)]) + +(documentation: /.at_least + "Parse at least N times." + [(at_least amount parser)]) + +(documentation: /.at_most + "Parse at most N times." + [(at_most amount parser)]) + +(documentation: /.between + "" + [(between minimum additional parser)]) + +(documentation: /.separated_by + "Parses instances of 'parser' that are separated by instances of 'separator'." + [(separated_by separator parser)]) + +(documentation: /.not + "Only succeeds when the underlying parser fails." + [(not parser)]) + +(documentation: /.failure + "Always fail with this 'message'." + [(failure message)]) + +(documentation: /.lifted + "Lift a potentially failed computation into a parser." + [(lifted operation)]) + +(documentation: /.else + "If the given parser fails, returns the default value." + [(else value parser)]) + +(documentation: /.remaining + "Yield the remaining input (without consuming it).") + +(documentation: /.rec + "Combinator for recursive parsers." + [(rec parser)]) + +(documentation: /.after + "Run the parser after another one (whose output is ignored)." + [(after param subject)]) + +(documentation: /.before + "Run the parser before another one (whose output is ignored)." + [(before param subject)]) + +(documentation: /.only + "Only succeed when the parser's output passes a test." + [(only test parser)]) + +(documentation: /.parses? + "Ignore a parser's output and just verify that it succeeds." + [(parses? parser)]) + +(documentation: /.parses + "Ignore a parser's output and just execute it." + [(parses parser)]) + +(documentation: /.speculative + (format "Executes a parser, without actually consuming the input." + \n "That way, the same input can be consumed again by another parser.") + [(speculative parser)]) + +(documentation: /.codec + "Decode the output of a parser using a codec." + [(codec codec parser)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Parser + ..assertion + ..maybe + ..result + ..and + ..or + ..either + ..some + ..many + ..exactly + ..at_least + ..at_most + ..between + ..separated_by + ..not + ..failure + ..lifted + ..else + ..remaining + ..rec + ..after + ..before + ..only + ..parses? + ..parses + ..speculative + ..codec + ($.default /.functor) + ($.default /.apply) + ($.default /.monad)] + [/analysis.documentation + /binary.documentation + /cli.documentation + /code.documentation + /environment.documentation + ... /json.documentation + ... /synthesis.documentation + ... /text.documentation + ... /tree.documentation + ... /type.documentation + ... /xml.documentation + ])) diff --git a/stdlib/source/documentation/lux/control/parser/analysis.lux b/stdlib/source/documentation/lux/control/parser/analysis.lux new file mode 100644 index 000000000..1f66be4bf --- /dev/null +++ b/stdlib/source/documentation/lux/control/parser/analysis.lux @@ -0,0 +1,71 @@ +(.module: + [library + [lux (#- nat int rev local) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Parser + "A parser for Lux code analysis nodes.") + +(documentation: /.result + "Executes a parser and makes sure no inputs go unconsumed." + [(result parser input)]) + +(documentation: /.any + "Matches any value, without discrimination.") + +(documentation: /.end! + "Ensures there are no more inputs.") + +(documentation: /.end? + "Checks whether there are no more inputs.") + +(template [<query> <assertion>] + [(`` (as_is (`` (documentation: <query> + (format "Queries for a " (~~ (template.text [<query>])) " value."))) + (`` (documentation: <assertion> + (format "Assert a specific " (~~ (template.text [<query>])) " value.")))))] + + [/.bit /.bit!] + [/.nat /.nat!] + [/.int /.int!] + [/.rev /.rev!] + [/.frac /.frac!] + [/.text /.text!] + [/.local /.local!] + [/.foreign /.foreign!] + [/.constant /.constant!] + ) + +(documentation: /.tuple + "Parses only within the context of a tuple's contents." + [(tuple parser)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Parser + ..result + ..any + ..end! + ..end? + ..bit ..bit! + ..nat ..nat! + ..int ..int! + ..rev ..rev! + ..frac ..frac! + ..text ..text! + ..local ..local! + ..foreign ..foreign! + ..constant ..constant! + ..tuple + ($.default /.cannot_parse) + ($.default /.unconsumed_input)] + [])) diff --git a/stdlib/source/documentation/lux/control/parser/binary.lux b/stdlib/source/documentation/lux/control/parser/binary.lux new file mode 100644 index 000000000..c20d3b0a7 --- /dev/null +++ b/stdlib/source/documentation/lux/control/parser/binary.lux @@ -0,0 +1,139 @@ +(.module: + [library + [lux (#- list) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Offset + "An offset for reading within binary data.") + +(documentation: /.Parser + "A parser for raw binary data.") + +(documentation: /.result + "Runs a parser and checks that all the binary data was read by it." + [(result parser input)]) + +(documentation: /.end? + "Checks whether there is no more data to read.") + +(documentation: /.offset + "The current offset (i.e. how much data has been read).") + +(documentation: /.remaining + "How much of the data remains to be read.") + +(documentation: /.Size + "The size of a chunk of data within a binary array.") + +(documentation: /.rec + "Tie the knot for a recursive parser.") + +(documentation: /.any + "Does no parsing, and just returns a dummy value.") + +(documentation: /.segment + "Parses a chunk of data of a given size." + [(segment size)]) + +(template [<size> <name>] + [(documentation: <name> + (format "Parses a block of data prefixed with a size that is " (%.nat <size>) " bytes long."))] + + [08 /.binary/8] + [16 /.binary/16] + [32 /.binary/32] + [64 /.binary/64] + ) + +(template [<size> <name>] + [(documentation: <name> + (format "Parses a block of (UTF-8 encoded) text prefixed with a size that is " (%.nat <size>) " bytes long."))] + + [08 /.utf8/8] + [16 /.utf8/16] + [32 /.utf8/32] + [64 /.utf8/64] + ) + +(template [<size> <name>] + [(documentation: <name> + (format "Parses a row of values prefixed with a size that is " (%.nat <size>) " bytes long."))] + + [08 /.row/8] + [16 /.row/16] + [32 /.row/32] + [64 /.row/64] + ) + +(documentation: /.list + "Parses an arbitrarily long list of values." + [(list value)]) + +(documentation: /.set + "" + [(set hash value)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Offset + ..Parser + ..result + ..end? + ..offset + ..remaining + ..Size + ..rec + ..any + ..segment + + ..binary/8 + ..binary/16 + ..binary/32 + ..binary/64 + + ..utf8/8 + ..utf8/16 + ..utf8/32 + ..utf8/64 + + ..row/8 + ..row/16 + ..row/32 + ..row/64 + + ..list + ..set + ($.default /.binary_was_not_fully_read) + ($.default /.size/8) + ($.default /.size/16) + ($.default /.size/32) + ($.default /.size/64) + ($.default /.bits/8) + ($.default /.bits/16) + ($.default /.bits/32) + ($.default /.bits/64) + ($.default /.nat) + ($.default /.int) + ($.default /.rev) + ($.default /.frac) + ($.default /.invalid_tag) + ($.default /.or) + ($.default /.not_a_bit) + ($.default /.bit) + ($.default /.text) + ($.default /.maybe) + ($.default /.set_elements_are_not_unique) + ($.default /.name) + ($.default /.type) + ($.default /.location) + ($.default /.code)] + [])) diff --git a/stdlib/source/documentation/lux/control/parser/cli.lux b/stdlib/source/documentation/lux/control/parser/cli.lux new file mode 100644 index 000000000..ecb2b4cb7 --- /dev/null +++ b/stdlib/source/documentation/lux/control/parser/cli.lux @@ -0,0 +1,59 @@ +(.module: + [library + [lux #* + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Parser + "A command-line interface parser.") + +(documentation: /.result + "Executes the parser and verifies that all inputs are processed." + [(result parser inputs)]) + +(documentation: /.any + "Just returns the next input without applying any logic.") + +(documentation: /.parse + "Parses the next input with a parsing function." + [(parse parser)]) + +(documentation: /.this + "Checks that a token is in the inputs." + [(this reference)]) + +(documentation: /.somewhere + "Given a parser, tries to parse it somewhere in the inputs (i.e. not necessarily parsing the immediate inputs)." + [(somewhere cli)]) + +(documentation: /.end + "Ensures there are no more inputs.") + +(documentation: /.named + "Parses a named parameter and yields its value." + [(named name value)]) + +(documentation: /.parameter + "Parses a parameter that can have either a short or a long name." + [(parameter [short long] value)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Parser + ..result + ..any + ..parse + ..this + ..somewhere + ..end + ..named + ..parameter] + [])) diff --git a/stdlib/source/documentation/lux/control/parser/code.lux b/stdlib/source/documentation/lux/control/parser/code.lux new file mode 100644 index 000000000..aa7e91442 --- /dev/null +++ b/stdlib/source/documentation/lux/control/parser/code.lux @@ -0,0 +1,113 @@ +(.module: + [library + [lux (#- nat int rev local) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Parser + "A Lux code parser.") + +(documentation: /.any + "Yields the next input without applying any logic.") + +(template [<query> <check>] + [(`` (documentation: <query> + (format "Parses the next " (~~ (template.text [<query>])) " input."))) + (`` (documentation: <check> + (format "Checks for a specific " (~~ (template.text [<query>])) " input.")))] + + [/.bit /.bit!] + [/.nat /.nat!] + [/.int /.int!] + [/.rev /.rev!] + [/.frac /.frac!] + [/.text /.text!] + [/.identifier /.identifier!] + [/.tag /.tag!] + ) + +(documentation: /.this! + "Ensures the given Code is the next input." + [(this! code)]) + +(template [<query> <check> <desc>] + [(documentation: <query> + (format "Parse a local " <desc> " (a " <desc> " that has no module prefix).")) + (documentation: <check> + (format "Checks for a specific local " <desc> " (a " <desc> " that has no module prefix)."))] + + [/.local_identifier /.local_identifier! "local identifier"] + [ /.local_tag /.local_tag! "local tag"] + ) + +(template [<name>] + [(`` (documentation: <name> + (format "Parses the contents of a " (~~ (template.text [<name>])) ".")))] + + [/.form] + [/.tuple] + ) + +(documentation: /.record + "Parses the contents of a record.") + +(documentation: /.end! + "Verifies there are no more inputs.") + +(documentation: /.end? + "Checks whether there are no more inputs.") + +(documentation: /.result + "Executes a parser against a stream of code, and verifies all the inputs are consumed." + [(result parser inputs)]) + +(documentation: /.local + "Runs parser against the given list of inputs." + [(local inputs parser)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Parser + ..any + + ..bit + ..bit! + ..nat + ..nat! + ..int + ..int! + ..rev + ..rev! + ..frac + ..frac! + ..text + ..text! + ..identifier + ..identifier! + ..tag + ..tag! + + ..this! + + ..local_identifier + ..local_identifier! + ..local_tag + ..local_tag! + + ..form + ..tuple + + ..record + ..end! + ..end? + ..result + ..local] + [])) diff --git a/stdlib/source/documentation/lux/control/parser/environment.lux b/stdlib/source/documentation/lux/control/parser/environment.lux new file mode 100644 index 000000000..f4961a0d4 --- /dev/null +++ b/stdlib/source/documentation/lux/control/parser/environment.lux @@ -0,0 +1,45 @@ +(.module: + [library + [lux #* + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Property + "A property in the environment.") + +(documentation: /.Environment + "An abstraction for environment variables of a program.") + +(documentation: /.Parser + "A parser of environment variables of a program.") + +(documentation: /.empty + "An empty environment.") + +(documentation: /.property + "" + [(property name)]) + +(documentation: /.result + (format "Executes a parser against the given environment variables." + \n "Does not check whether all environment variables were parsed, since they're usually an open set.") + [(result parser environment)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Property + ..Environment + ..Parser + ..empty + ..property + ..result + ($.default /.unknown_property)] + [])) diff --git a/stdlib/source/documentation/lux/control/pipe.lux b/stdlib/source/documentation/lux/control/pipe.lux new file mode 100644 index 000000000..f18415290 --- /dev/null +++ b/stdlib/source/documentation/lux/control/pipe.lux @@ -0,0 +1,117 @@ +(.module: + [library + [lux (#- if loop) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.new> + "Ignores the piped argument, and begins a new pipe." + [(n.= 1 + (|> 20 + (n.* 3) + (n.+ 4) + (new> 0 [++])))]) + +(documentation: /.let> + "Gives a name to the piped-argument, within the given expression." + [(n.= 10 + (|> 5 + (let> x (n.+ x x))))]) + +(documentation: /.cond> + (format "Branching for pipes." + \n "Both the tests and the bodies are piped-code, and must be given inside a tuple.") + [(|> +5 + (cond> [i.even?] [(i.* +2)] + [i.odd?] [(i.* +3)] + [(new> -1 [])]))]) + +(documentation: /.if> + "If-branching." + [(same? (if (n.even? sample) + "even" + "odd") + (|> sample + (if> [n.even?] + [(new> "even" [])] + [(new> "odd" [])])))]) + +(documentation: /.when> + "Only execute the body when the test passes." + [(same? (if (n.even? sample) + (n.* 2 sample) + sample) + (|> sample + (when> [n.even?] + [(n.* 2)])))]) + +(documentation: /.loop> + (format "Loops for pipes." + \n "Both the testing and calculating steps are pipes and must be given inside tuples.") + [(|> +1 + (loop> [(i.< +10)] + [++]))]) + +(documentation: /.do> + (format "Monadic pipes." + \n "Each steps in the monadic computation is a pipe and must be given inside a tuple.") + [(|> +5 + (do> identity.monad + [(i.* +3)] + [(i.+ +4)] + [++]))]) + +(documentation: /.exec> + (format "Non-updating pipes." + \n "Will generate piped computations, but their results will not be used in the larger scope.") + [(|> +5 + (exec> [.nat %n log!]) + (i.* +10))]) + +(documentation: /.tuple> + (format "Parallel branching for pipes." + \n "Allows to run multiple pipelines for a value and gives you a tuple of the outputs.") + [(|> +5 + (tuple> [(i.* +10)] + [-- (i./ +2)] + [i\encode])) + "=>" + [+50 +2 "+5"]]) + +(documentation: /.case> + (format "Pattern-matching for pipes." + \n "The bodies of each branch are NOT pipes; just regular values.") + [(|> +5 + (case> +0 "zero" + +1 "one" + +2 "two" + +3 "three" + +4 "four" + +5 "five" + +6 "six" + +7 "seven" + +8 "eight" + +9 "nine" + _ "???"))]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..new> + ..let> + ..cond> + ..if> + ..when> + ..loop> + ..do> + ..exec> + ..tuple> + ..case>] + [])) diff --git a/stdlib/source/documentation/lux/control/reader.lux b/stdlib/source/documentation/lux/control/reader.lux new file mode 100644 index 000000000..959c44217 --- /dev/null +++ b/stdlib/source/documentation/lux/control/reader.lux @@ -0,0 +1,47 @@ +(.module: + [library + [lux (#- local) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Reader + "Computations that have access to some environmental value.") + +(documentation: /.read + "Get the environment.") + +(documentation: /.local + "Run computation with a locally-modified environment." + [(local change proc)]) + +(documentation: /.result + "Executes the reader against the given environment." + [(result env proc)]) + +(documentation: /.with + "Monad transformer for Reader." + [(with monad)]) + +(documentation: /.lifted + "Lift monadic values to the Reader wrapper.") + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Reader + ..read + ..local + ..result + ..with + ..lifted + ($.default /.functor) + ($.default /.apply) + ($.default /.monad)] + [])) diff --git a/stdlib/source/documentation/lux/control/region.lux b/stdlib/source/documentation/lux/control/region.lux new file mode 100644 index 000000000..08e8177b9 --- /dev/null +++ b/stdlib/source/documentation/lux/control/region.lux @@ -0,0 +1,51 @@ +(.module: + [library + [lux (#- if loop) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Region + (format "A region where resources may be be claimed and where a side-effecting computation may be performed." + \n "Every resource is paired with a function that knows how to clean/reclaim it, to make sure there are no leaks.")) + +(documentation: /.run! + "Executes a region-based computation, with a side-effect determined by the monad." + [(run! monad computation)]) + +(documentation: /.acquire! + "Acquire a resource while pairing it a function that knows how to reclaim it." + [(acquire! monad cleaner value)]) + +(documentation: /.failure + "Immediately fail with this 'message'." + [(failure monad error)]) + +(documentation: /.except + "Fail by throwing/raising an exception." + [(except monad exception message)]) + +(documentation: /.lifted + "Lift an effectful computation into a region-based computation." + [(lifted monad operation)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Region + ..run! + ..acquire! + ..failure + ..except + ..lifted + ($.default /.clean_up_error) + ($.default /.functor) + ($.default /.apply) + ($.default /.monad)] + [])) diff --git a/stdlib/source/documentation/lux/control/remember.lux b/stdlib/source/documentation/lux/control/remember.lux new file mode 100644 index 000000000..c17fdf3cc --- /dev/null +++ b/stdlib/source/documentation/lux/control/remember.lux @@ -0,0 +1,38 @@ +(.module: + [library + [lux #* + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(template [<name> <type>] + [(`` (documentation: <name> + (format "A" <type> " message with an expiration date." + \n "Can have an optional piece of code to focus on.") + [((~~ (template.identifier [<name>])) + "2022-04-01" + "Do this, that and the other.")] + [((~~ (template.identifier [<name>])) + "2022-04-01" + "Improve the performace." + (some (complicated (computation 123))))]))] + + [/.remember ""] + [/.to_do " TODO"] + [/.fix_me " FIXME"] + ) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..remember + ..to_do + ..fix_me + ($.default /.must_remember)] + [])) diff --git a/stdlib/source/documentation/lux/control/security.lux b/stdlib/source/documentation/lux/control/security.lux new file mode 100644 index 000000000..ac39298dd --- /dev/null +++ b/stdlib/source/documentation/lux/control/security.lux @@ -0,0 +1,18 @@ +(.module: + [library + [lux #* + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]] + [collection + ["." list]]]]] + ["." / #_ + ["#." capability] + ["#." policy]]) + +(.def: .public documentation + (.List $.Module) + (list.together + (list /policy.documentation + /capability.documentation))) diff --git a/stdlib/source/documentation/lux/control/security/capability.lux b/stdlib/source/documentation/lux/control/security/capability.lux new file mode 100644 index 000000000..fb43184d8 --- /dev/null +++ b/stdlib/source/documentation/lux/control/security/capability.lux @@ -0,0 +1,44 @@ +(.module: + [library + [lux #* + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Capability + (format "Represents the capability to perform an operation." + \n "This operation is assumed to have security implications.")) + +(documentation: /.use + "Applies a capability against its required input." + [(use capability input)]) + +(documentation: /.capability: + "Defines a capability as a unique type, and a constructor for instances." + [(capability: (Can_Duplicate a) + (can_duplicate a [a a])) + + (let [capability (can_duplicate + (function (_ value) + [value value])) + [left right] (..use capability 123)] + (same? left right))]) + +(documentation: /.async + "Converts a synchronous I/O-based capability into an asynchronous capability." + [(async capability)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Capability + ..use + ..capability: + ..async] + [])) diff --git a/stdlib/source/documentation/lux/control/security/policy.lux b/stdlib/source/documentation/lux/control/security/policy.lux new file mode 100644 index 000000000..9d9cb655d --- /dev/null +++ b/stdlib/source/documentation/lux/control/security/policy.lux @@ -0,0 +1,89 @@ +(.module: + [library + [lux #* + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Policy + "A security policy encoded as the means to 'upgrade' or 'downgrade' in a secure context.") + +(documentation: /.Can_Upgrade + "Represents the capacity to 'upgrade' a value.") + +(documentation: /.Can_Downgrade + "Represents the capacity to 'downgrade' a value.") + +(documentation: /.Privilege + "Represents the privilege to both 'upgrade' and 'downgrade' a value.") + +(documentation: /.Delegation + "Represents the act of delegating policy capacities.") + +(documentation: /.delegation + "Delegating policy capacities." + [(delegation downgrade upgrade)]) + +(documentation: /.Context + "A computational context with an associated policy privilege.") + +(documentation: /.with_policy + "Activates a security context with the priviledge to enforce it's policy." + [(type: Password + (Private Text)) + + (interface: (Policy %) + (: (-> Text (Password %)) + password) + (: (-> (Password %) Text) + unsafe)) + + (def: (policy _) + (Ex [%] (-> Any (Policy %))) + (with_policy + (: (Context Privacy Policy) + (function (_ (^open "%::.")) + (implementation + (def: (password value) + (%::can_upgrade value)) + (def: (unsafe password) + (%::can_downgrade password)))))))] + [(with_policy context)]) + +(documentation: /.Privacy + (format "A security context for privacy." + \n "Private data is data which cannot be allowed to leak outside of the programmed.")) + +(documentation: /.Safety + (format "A security context for safety." + \n "Safe data is data coming from outside the program which can be trusted to be properly formatted and lacking injections.")) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Policy + ..Can_Upgrade + ..Can_Downgrade + ..Privilege + ..Delegation + ..delegation + ..Context + ..with_policy + ..Privacy + ..Safety + ($.default /.functor) + ($.default /.apply) + ($.default /.monad) + ($.default /.Private) + ($.default /.Can_Conceal) + ($.default /.Can_Reveal) + ($.default /.Safe) + ($.default /.Can_Trust) + ($.default /.Can_Distrust)] + [])) diff --git a/stdlib/source/documentation/lux/control/state.lux b/stdlib/source/documentation/lux/control/state.lux new file mode 100644 index 000000000..99be4d130 --- /dev/null +++ b/stdlib/source/documentation/lux/control/state.lux @@ -0,0 +1,82 @@ +(.module: + [library + [lux (#- local) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.State + "Stateful computations.") + +(documentation: /.get + "Read the current state.") + +(documentation: /.put + "Set the new state." + [(put new_state)]) + +(documentation: /.update + "Compute the new state." + [(update change)]) + +(documentation: /.use + "Run a function on the current state." + [(use user)]) + +(documentation: /.local + "Run the computation with a locally-modified state." + [(local change action)]) + +(documentation: /.result + "Run a stateful computation." + [(result state action)]) + +(documentation: /.while + "A stateful while loop." + [(while condition body)]) + +(documentation: /.do_while + "A stateful do-while loop." + [(do_while condition body)]) + +(documentation: /.+State + "Stateful computations decorated by a monad.") + +(documentation: /.result' + "Execute a stateful computation decorated by a monad." + [(result' state action)]) + +(documentation: /.with + "A monad transformer to create composite stateful computations." + [(with monad)]) + +(documentation: /.lifted + "Lift monadic values to the +State wrapper." + [(lifted monad ma)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..State + ..get + ..put + ..update + ..use + ..local + ..result + ..while + ..do_while + ..+State + ..result' + ..with + ..lifted + ($.default /.functor) + ($.default /.apply) + ($.default /.monad)] + [])) diff --git a/stdlib/source/documentation/lux/control/thread.lux b/stdlib/source/documentation/lux/control/thread.lux new file mode 100644 index 000000000..cc3134d2f --- /dev/null +++ b/stdlib/source/documentation/lux/control/thread.lux @@ -0,0 +1,57 @@ +(.module: + [library + [lux (#- local) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Thread + "An imperative process with access to mutable values.") + +(documentation: /.Box + "A mutable box holding a value.") + +(documentation: /.box + "A brand-new box initialized to the given value." + [(box init)]) + +(documentation: /.read! + "Reads the current value in the box." + [(read! box)]) + +(documentation: /.write! + "Mutates the value in the box." + [(write! value box)]) + +(documentation: /.result + "Executes the imperative thread in a self-contained way." + [(result thread)]) + +(documentation: /.io + "Transforms the imperative thread into an I/O computation.") + +(documentation: /.update! + "Update a box's value by applying a function to it." + [(update! f box)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Thread + ..Box + ..box + ..read! + ..write! + ..result + ..io + ..update! + ($.default /.functor) + ($.default /.apply) + ($.default /.monad)] + [])) diff --git a/stdlib/source/documentation/lux/control/try.lux b/stdlib/source/documentation/lux/control/try.lux new file mode 100644 index 000000000..7b226c132 --- /dev/null +++ b/stdlib/source/documentation/lux/control/try.lux @@ -0,0 +1,62 @@ +(.module: + [library + [lux (#- local) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Try + "A computation that can fail with an error message.") + +(documentation: /.with + "Enhances a monad with error-handling functionality." + [(with monad)]) + +(documentation: /.lifted + "Wraps a monadic value with error-handling machinery." + [(lifted monad)]) + +(documentation: /.trusted + (format "Assumes a Try value succeeded, and yields its value." + \n "If it didn't, raises the error as a runtime error." + \n "WARNING: Use with caution.") + [(trusted try)]) + +(documentation: /.maybe + "" + [(maybe try)]) + +(documentation: /.of_maybe + "" + [(of_maybe maybe)]) + +(documentation: /.else + (format "Allows you to provide a default value that will be used" + \n "if a (Try x) value turns out to be #Failure." + \n "Note: the expression for the default value will not be computed if the base computation succeeds.") + [(= "bar" + (else "foo" (#..Success "bar")))] + [(= "foo" + (else "foo" (#..Failure "KABOOM!")))]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Try + ..with + ..lifted + ..trusted + ..maybe + ..of_maybe + ..else + ($.default /.functor) + ($.default /.apply) + ($.default /.monad) + ($.default /.equivalence)] + [])) diff --git a/stdlib/source/documentation/lux/control/writer.lux b/stdlib/source/documentation/lux/control/writer.lux new file mode 100644 index 000000000..99cbe0463 --- /dev/null +++ b/stdlib/source/documentation/lux/control/writer.lux @@ -0,0 +1,39 @@ +(.module: + [library + [lux (#- local) + ["$" documentation (#+ documentation:)] + [data + [text (#+ \n) + ["%" format (#+ format)]]] + [macro + ["." template]]]] + [\\library + ["." /]]) + +(documentation: /.Writer + "Represents a value with an associated 'log' to record arbitrary information.") + +(documentation: /.write + "Write a value to the log." + [(write message)]) + +(documentation: /.with + "Enhances a monad with Writer functionality." + [(with monoid monad)]) + +(documentation: /.lifted + "Wraps a monadic value with Writer machinery." + [(lifted monoid monad)]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Writer + ..write + ..with + ..lifted + ($.default /.functor) + ($.default /.apply) + ($.default /.monad)] + [])) diff --git a/stdlib/source/library/lux.lux b/stdlib/source/library/lux.lux index f9be2bf36..6554978c9 100644 --- a/stdlib/source/library/lux.lux +++ b/stdlib/source/library/lux.lux @@ -2109,8 +2109,8 @@ "... By specifying a pattern (with holes), and the input data to fill those holes, repeats the pattern as many times as necessary." __paragraph "(template [<name> <diff>]" ..\n " " "[(def: .public <name> (-> Int Int) (+ <diff>))]" __paragraph - " " "[inc +1]" ..\n - " " "[dec -1]"))]) + " " "[++ +1]" ..\n + " " "[-- -1]"))]) ({(#Item [[_ (#Tuple bindings)] (#Item [[_ (#Tuple templates)] data])]) ({[(#Some bindings') (#Some data')] (let' [apply ("lux type check" (-> Replacement_Environment ($' List Code)) @@ -4460,16 +4460,16 @@ (All [a] (-> (List a) (List [Nat a]))) (enumeration' 0 xs)) -(macro: .public (get@ tokens) +(macro: .public (value@ tokens) {#.doc (text$ ($_ "lux text concat" "... Accesses the value of a record at a given tag." ..\n - "(get@ #field my_record)" + "(value@ #field my_record)" __paragraph "... Can also work with multiple levels of nesting:" ..\n - "(get@ [#foo #bar #baz] my_record)" + "(value@ [#foo #bar #baz] my_record)" __paragraph "... And, if only the slot/path is given, generates an accessor function:" ..\n - "(let [getter (get@ [#foo #bar #baz])]" ..\n + "(let [getter (value@ [#foo #bar #baz])]" ..\n " (getter my_record))"))} (case tokens (^ (list [_ (#Tag slot')] record)) @@ -4491,12 +4491,12 @@ (in_meta (list (` ({(~ pattern) (~ g!output)} (~ record)))))) _ - (failure "get@ can only use records."))) + (failure "value@ can only use records."))) (^ (list [_ (#Tuple slots)] record)) (in_meta (list (list\fold (: (-> Code Code Code) (function (_ slot inner) - (` (..get@ (~ slot) (~ inner))))) + (` (..value@ (~ slot) (~ inner))))) record slots))) @@ -4504,10 +4504,10 @@ (do meta_monad [g!_ (..identifier "_") g!record (..identifier "record")] - (in (list (` (function ((~ g!_) (~ g!record)) (..get@ (~ selector) (~ g!record))))))) + (in (list (` (function ((~ g!_) (~ g!record)) (..value@ (~ selector) (~ g!record))))))) _ - (failure "Wrong syntax for get@"))) + (failure "Wrong syntax for value@"))) (def: (open_declaration alias tags my_tag_index [module short] source type) (-> Text (List Name) Nat Name Code Type (Meta (List Code))) @@ -4774,17 +4774,17 @@ _ (failure "Wrong syntax for \"))) -(macro: .public (set@ tokens) +(macro: .public (with@ tokens) {#.doc (text$ ($_ "lux text concat" "... Sets the value of a record at a given tag." ..\n - "(set@ #name ''Lux'' lang)" + "(with@ #name ''Lux'' lang)" __paragraph "... Can also work with multiple levels of nesting:" ..\n - "(set@ [#foo #bar #baz] value my_record)" + "(with@ [#foo #bar #baz] value my_record)" __paragraph "... And, if only the slot/path and (optionally) the value are given, generates a mutator function:" ..\n - "(let [setter (set@ [#foo #bar #baz] value)] (setter my_record))" ..\n - "(let [setter (set@ [#foo #bar #baz])] (setter value my_record))"))} + "(let [setter (with@ [#foo #bar #baz] value)] (setter my_record))" ..\n + "(let [setter (with@ [#foo #bar #baz])] (setter value my_record))"))} (case tokens (^ (list [_ (#Tag slot')] value record)) (do meta_monad @@ -4816,12 +4816,12 @@ (in_meta (list (` ({(~ pattern) (~ output)} (~ record))))))) _ - (failure "set@ can only use records."))) + (failure "with@ can only use records."))) (^ (list [_ (#Tuple slots)] value record)) (case slots #End - (failure "Wrong syntax for set@") + (failure "Wrong syntax for with@") _ (do meta_monad @@ -4832,12 +4832,12 @@ .let [pairs (zipped/2 slots bindings) update_expr (list\fold (: (-> [Code Code] Code Code) (function (_ [s b] v) - (` (..set@ (~ s) (~ v) (~ b))))) + (` (..with@ (~ s) (~ v) (~ b))))) value (list\reverse pairs)) [_ accesses'] (list\fold (: (-> [Code Code] [Code (List (List Code))] [Code (List (List Code))]) (function (_ [new_slot new_binding] [old_record accesses']) - [(` (get@ (~ new_slot) (~ new_binding))) + [(` (value@ (~ new_slot) (~ new_binding))) (#Item (list new_binding old_record) accesses')])) [record (: (List (List Code)) #End)] pairs) @@ -4850,7 +4850,7 @@ [g!_ (..identifier "_") g!record (..identifier "record")] (in (list (` (function ((~ g!_) (~ g!record)) - (..set@ (~ selector) (~ value) (~ g!record))))))) + (..with@ (~ selector) (~ value) (~ g!record))))))) (^ (list selector)) (do meta_monad @@ -4858,22 +4858,22 @@ g!value (..identifier "value") g!record (..identifier "record")] (in (list (` (function ((~ g!_) (~ g!value) (~ g!record)) - (..set@ (~ selector) (~ g!value) (~ g!record))))))) + (..with@ (~ selector) (~ g!value) (~ g!record))))))) _ - (failure "Wrong syntax for set@"))) + (failure "Wrong syntax for with@"))) -(macro: .public (update@ tokens) +(macro: .public (revised@ tokens) {#.doc (text$ ($_ "lux text concat" "... Modifies the value of a record at a given tag, based on some function." ..\n - "(update@ #age inc person)" + "(revised@ #age ++ person)" __paragraph "... Can also work with multiple levels of nesting:" ..\n - "(update@ [#foo #bar #baz] func my_record)" + "(revised@ [#foo #bar #baz] func my_record)" __paragraph "... And, if only the slot/path and (optionally) the value are given, generates a mutator function:" ..\n - "(let [updater (update@ [#foo #bar #baz] func)] (updater my_record))" ..\n - "(let [updater (update@ [#foo #bar #baz])] (updater func my_record))"))} + "(let [updater (revised@ [#foo #bar #baz] func)] (updater my_record))" ..\n + "(let [updater (revised@ [#foo #bar #baz])] (updater func my_record))"))} (case tokens (^ (list [_ (#Tag slot')] fun record)) (do meta_monad @@ -4905,27 +4905,27 @@ (in_meta (list (` ({(~ pattern) (~ output)} (~ record))))))) _ - (failure "update@ can only use records."))) + (failure "revised@ can only use records."))) (^ (list [_ (#Tuple slots)] fun record)) (case slots #End - (failure "Wrong syntax for update@") + (failure "Wrong syntax for revised@") _ (do meta_monad [g!record (..identifier "record") g!temp (..identifier "temp")] (in (list (` (let [(~ g!record) (~ record) - (~ g!temp) (get@ [(~+ slots)] (~ g!record))] - (set@ [(~+ slots)] ((~ fun) (~ g!temp)) (~ g!record)))))))) + (~ g!temp) (value@ [(~+ slots)] (~ g!record))] + (with@ [(~+ slots)] ((~ fun) (~ g!temp)) (~ g!record)))))))) (^ (list selector fun)) (do meta_monad [g!_ (..identifier "_") g!record (..identifier "record")] (in (list (` (function ((~ g!_) (~ g!record)) - (..update@ (~ selector) (~ fun) (~ g!record))))))) + (..revised@ (~ selector) (~ fun) (~ g!record))))))) (^ (list selector)) (do meta_monad @@ -4933,10 +4933,10 @@ g!fun (..identifier "fun") g!record (..identifier "record")] (in (list (` (function ((~ g!_) (~ g!fun) (~ g!record)) - (..update@ (~ selector) (~ g!fun) (~ g!record))))))) + (..revised@ (~ selector) (~ g!fun) (~ g!record))))))) _ - (failure "Wrong syntax for update@"))) + (failure "Wrong syntax for revised@"))) (macro: .public (^template tokens) {#.doc (text$ ($_ "lux text concat" @@ -5047,8 +5047,8 @@ (All [s] (-> (I64 s) (I64 s))) (|>> (<extension> 1)))] - [inc "lux i64 +" "Increment function."] - [dec "lux i64 -" "Decrement function."] + [++ "lux i64 +" "Increment function."] + [-- "lux i64 -" "Decrement function."] ) (def: tag\encode @@ -5107,9 +5107,9 @@ (let [[group_location' parts_text] (list\fold (function (_ part [last_location text_accum]) (let [[part_location part_text] (example_documentation last_location baseline part)] [part_location (text\compose text_accum part_text)])) - [(update@ #column inc group_location) ""] + [(revised@ #column ++ group_location) ""] (<prep> parts))] - [(update@ #column inc group_location') + [(revised@ #column ++ group_location') ($_ text\compose (location_padding baseline prev_location group_location) <open> parts_text @@ -5134,7 +5134,7 @@ (#Documentation_Example example) (let [baseline (baseline_column example) [location _] example - [_ text] (..example_documentation (set@ #.column baseline location) baseline example)] + [_ text] (..example_documentation (with@ #.column baseline location) baseline example)] (text\compose text __paragraph)))) (macro: .public (example tokens) @@ -5147,7 +5147,7 @@ " (loop [count +0" ..\n " x init]" ..\n " (if (< +10 count)" ..\n - " (recur (inc count) (f x))" ..\n + " (recur (++ count) (f x))" ..\n " x)))"))} (in_meta (list (` [(~ location_code) (#.Text (~ (|> tokens @@ -5206,7 +5206,7 @@ (loop [count +0 x init] (if (< +10 count) - (recur (inc count) (f x)) + (recur (++ count) (f x)) x)) "Loops can also be given custom names." @@ -5214,7 +5214,7 @@ [count +0 x init] (if (< +10 count) - (my_loop (inc count) (f x)) + (my_loop (++ count) (f x)) x)))} (let [?params (case tokens (^ (list name [_ (#Tuple bindings)] body)) @@ -5665,7 +5665,7 @@ (macro: .public (^|> tokens) {#.doc (example "Pipes the value being pattern-matched against prior to binding it to a variable." (case input - (^|> value [inc (% 10) (max 1)]) + (^|> value [++ (% 10) (max 1)]) (foo value)))} (case tokens (^ (list& [_meta (#Form (list [_ (#Identifier ["" name])] [_ (#Tuple steps)]))] body branches)) @@ -5696,7 +5696,7 @@ {#.doc "The location of the current expression being analyzed."} (Meta Location) (function (_ compiler) - (#Right [compiler (get@ #location compiler)]))) + (#Right [compiler (value@ #location compiler)]))) (macro: .public (undefined tokens) {#.doc (example "Meant to be used as a stand-in for functions with undefined implementations." @@ -5845,7 +5845,7 @@ (def: target (Meta Text) (function (_ compiler) - (#Right [compiler (get@ [#info #target] compiler)]))) + (#Right [compiler (value@ [#info #target] compiler)]))) (def: (platform_name choice) (-> Code (Meta Text)) diff --git a/stdlib/source/library/lux/abstract/apply.lux b/stdlib/source/library/lux/abstract/apply.lux index 7b57f5671..0b80263e8 100644 --- a/stdlib/source/library/lux/abstract/apply.lux +++ b/stdlib/source/library/lux/abstract/apply.lux @@ -19,7 +19,8 @@ (Apply (All [a] (F (G a)))))) (def: &functor - (functor.composite (get@ #&functor f_apply) (get@ #&functor g_apply))) + (functor.composite (value@ #&functor f_apply) + (value@ #&functor g_apply))) (def: (apply fgf fgx) ... TODO: Switch from this version to the one below (in comments) ASAP. diff --git a/stdlib/source/library/lux/abstract/interval.lux b/stdlib/source/library/lux/abstract/interval.lux index cea44c57b..4c6060d4d 100644 --- a/stdlib/source/library/lux/abstract/interval.lux +++ b/stdlib/source/library/lux/abstract/interval.lux @@ -25,7 +25,6 @@ (def: top top))) (def: .public (singleton enum elem) - {#.doc (example "An interval where both top and bottom are the same value.")} (All [a] (-> (Enum a) a (Interval a))) (implementation (def: &enum enum) @@ -76,21 +75,21 @@ (implementation: .public (union left right) (All [a] (-> (Interval a) (Interval a) (Interval a))) - (def: &enum (get@ #&enum right)) + (def: &enum (value@ #&enum right)) (def: bottom (order.min (\ right &order) (\ left bottom) (\ right bottom))) (def: top (order.max (\ right &order) (\ left top) (\ right top)))) (implementation: .public (intersection left right) (All [a] (-> (Interval a) (Interval a) (Interval a))) - (def: &enum (get@ #&enum right)) + (def: &enum (value@ #&enum right)) (def: bottom (order.max (\ right &order) (\ left bottom) (\ right bottom))) (def: top (order.min (\ right &order) (\ left top) (\ right top)))) (implementation: .public (complement interval) (All [a] (-> (Interval a) (Interval a))) - (def: &enum (get@ #&enum interval)) + (def: &enum (value@ #&enum interval)) (def: bottom (\ interval succ (\ interval top))) (def: top (\ interval pred (\ interval bottom)))) diff --git a/stdlib/source/library/lux/abstract/monad.lux b/stdlib/source/library/lux/abstract/monad.lux index 6ba4f74aa..2d81c09e7 100644 --- a/stdlib/source/library/lux/abstract/monad.lux +++ b/stdlib/source/library/lux/abstract/monad.lux @@ -25,7 +25,7 @@ counter (#.Item _ xs') - (recur (inc counter) xs')))) + (recur (++ counter) xs')))) (def: (reversed xs) (All [a] @@ -105,17 +105,17 @@ #.None (#.Left "Wrong syntax for 'do'"))) -(def: .public (bind monad f) +(def: .public (then monad f) (All [! a b] (-> (Monad !) (-> a (! b)) (-> (! a) (! b)))) (|>> (\ monad map f) (\ monad join))) -(def: .public (seq monad) - (All [M a] - (-> (Monad M) (List (M a)) - (M (List a)))) +(def: .public (all monad) + (All [! a] + (-> (Monad !) (List (! a)) + (! (List a)))) (let [(^open "!\.") monad] (function (recur xs) (case xs diff --git a/stdlib/source/library/lux/abstract/monad/indexed.lux b/stdlib/source/library/lux/abstract/monad/indexed.lux index 9f64ec76d..b43ac87e8 100644 --- a/stdlib/source/library/lux/abstract/monad/indexed.lux +++ b/stdlib/source/library/lux/abstract/monad/indexed.lux @@ -21,7 +21,7 @@ (-> (-> vi (m it io vo)) (m ii it vi) (m ii io vo))) - bind)) + then)) (type: Binding [Code Code]) @@ -32,7 +32,7 @@ (type: Context (#Macro Name Code) - (#Bind Binding)) + (#Binding Binding)) (def: global_identifier (Parser Name) @@ -62,7 +62,7 @@ (syntax: .public (do [[?name monad] ..named_monad context (<code>.tuple (<>.some context)) expression <code>.any]) - (macro.with_identifiers [g!_ g!bind] + (macro.with_identifiers [g!_ g!then] (let [body (list\fold (function (_ context next) (case context (#Macro macro parameter) @@ -70,8 +70,8 @@ (~ parameter) (~ next))) - (#Bind [binding value]) - (` ((~ g!bind) + (#Binding [binding value]) + (` ((~ g!then) (.function ((~ g!_) (~ binding)) (~ next)) (~ value))))) @@ -82,10 +82,10 @@ (let [name (code.local_identifier name)] (` (let [(~ name) (~ monad) {#..in (~' in) - #..bind (~ g!bind)} (~ name)] + #..then (~ g!then)} (~ name)] (~ body)))) #.None (` (let [{#..in (~' in) - #..bind (~ g!bind)} (~ monad)] + #..then (~ g!then)} (~ monad)] (~ body))))))))) diff --git a/stdlib/source/library/lux/abstract/monoid.lux b/stdlib/source/library/lux/abstract/monoid.lux index 53c3288c6..fac4862ae 100644 --- a/stdlib/source/library/lux/abstract/monoid.lux +++ b/stdlib/source/library/lux/abstract/monoid.lux @@ -3,8 +3,6 @@ [lux #*]]) (interface: .public (Monoid a) - {#.doc (example "A way to compose values." - "Includes an identity value which does not alter any other value when combined with.")} (: a identity) (: (-> a a a) diff --git a/stdlib/source/library/lux/control/concatenative.lux b/stdlib/source/library/lux/control/concatenative.lux index 03ae8afe6..93a99ceb2 100644 --- a/stdlib/source/library/lux/control/concatenative.lux +++ b/stdlib/source/library/lux/control/concatenative.lux @@ -78,20 +78,20 @@ (code.replaced (code.local_identifier from) to pre)) aliased aliases))] - (case [(|> inputs (get@ #bottom) (maybe\map (|>> code.nat (~) #.Parameter (`)))) - (|> outputs (get@ #bottom) (maybe\map (|>> code.nat (~) #.Parameter (`))))] + (case [(|> inputs (value@ #bottom) (maybe\map (|>> code.nat (~) #.Parameter (`)))) + (|> outputs (value@ #bottom) (maybe\map (|>> code.nat (~) #.Parameter (`))))] [(#.Some bottomI) (#.Some bottomO)] (monad.do meta.monad - [inputC (singleton (macro.full_expansion (stack_fold (get@ #top inputs) bottomI))) - outputC (singleton (macro.full_expansion (stack_fold (get@ #top outputs) bottomO)))] + [inputC (singleton (macro.full_expansion (stack_fold (value@ #top inputs) bottomI))) + outputC (singleton (macro.full_expansion (stack_fold (value@ #top outputs) bottomO)))] (in (list (` (-> (~ (de_alias inputC)) (~ (de_alias outputC))))))) [?bottomI ?bottomO] (with_identifiers [g!stack] (monad.do meta.monad - [inputC (singleton (macro.full_expansion (stack_fold (get@ #top inputs) (maybe.else g!stack ?bottomI)))) - outputC (singleton (macro.full_expansion (stack_fold (get@ #top outputs) (maybe.else g!stack ?bottomO))))] + [inputC (singleton (macro.full_expansion (stack_fold (value@ #top inputs) (maybe.else g!stack ?bottomI)))) + outputC (singleton (macro.full_expansion (stack_fold (value@ #top outputs) (maybe.else g!stack ?bottomO))))] (in (list (` (All [(~ g!stack)] (-> (~ (de_alias inputC)) (~ (de_alias outputC)))))))))))) @@ -130,7 +130,7 @@ (syntax: .public (apply [arity (<>.only (n.> 0) <code>.nat)]) (with_identifiers [g! g!func g!stack g!output] (monad.do {! meta.monad} - [g!inputs (|> (macro.identifier "input") (list.repeated arity) (monad.seq !))] + [g!inputs (|> (macro.identifier "input") (list.repeated arity) (monad.all !))] (in (list (` (: (All [(~+ g!inputs) (~ g!output)] (-> (-> (~+ g!inputs) (~ g!output)) (=> [(~+ g!inputs)] [(~ g!output)]))) diff --git a/stdlib/source/library/lux/control/concurrency/actor.lux b/stdlib/source/library/lux/control/concurrency/actor.lux index e51be0b98..20ab00c06 100644 --- a/stdlib/source/library/lux/control/concurrency/actor.lux +++ b/stdlib/source/library/lux/control/concurrency/actor.lux @@ -90,13 +90,13 @@ (:abstraction {#obituary (async.async []) #mailbox (atom (async.async []))})) process (loop [state (on_init init) - [|mailbox| _] (io.run! (atom.read! (get@ #mailbox (:representation self))))] + [|mailbox| _] (io.run! (atom.read! (value@ #mailbox (:representation self))))] (do {! async.monad} [[head tail] |mailbox| ?state' (on_mail head state self)] (case ?state' (#try.Failure error) - (let [[_ resolve] (get@ #obituary (:representation self))] + (let [[_ resolve] (value@ #obituary (:representation self))] (exec (io.run! (do io.monad [pending (..pending tail)] @@ -109,7 +109,7 @@ (def: .public (alive? actor) (All [s] (-> (Actor s) (IO Bit))) - (let [[obituary _] (get@ #obituary (:representation actor))] + (let [[obituary _] (value@ #obituary (:representation actor))] (|> obituary async.value (\ io.functor map @@ -121,13 +121,13 @@ (def: .public (obituary' actor) (All [s] (-> (Actor s) (IO (Maybe (Obituary s))))) - (let [[obituary _] (get@ #obituary (:representation actor))] + (let [[obituary _] (value@ #obituary (:representation actor))] (async.value obituary))) (def: .public obituary (All [s] (-> (Actor s) (Async (Obituary s)))) (|>> :representation - (get@ #obituary) + (value@ #obituary) product.left)) (def: .public (mail! mail actor) @@ -137,7 +137,7 @@ (if alive? (let [entry [mail (async.async [])]] (do ! - [|mailbox|&resolve (atom.read! (get@ #mailbox (:representation actor)))] + [|mailbox|&resolve (atom.read! (value@ #mailbox (:representation actor)))] (loop [[|mailbox| resolve] |mailbox|&resolve] (do ! [|mailbox| (async.value |mailbox|)] @@ -147,7 +147,7 @@ [resolved? (resolve entry)] (if resolved? (do ! - [_ (atom.write! (product.right entry) (get@ #mailbox (:representation actor)))] + [_ (atom.write! (product.right entry) (value@ #mailbox (:representation actor)))] (in (#try.Success []))) (recur |mailbox|&resolve))) @@ -323,27 +323,27 @@ (with_identifiers [g!_ g!return] (do meta.monad [actor_scope abstract.current - .let [g!type (code.local_identifier (get@ #abstract.name actor_scope)) - g!message (code.local_identifier (get@ #name signature)) - g!actor_vars (get@ #abstract.type_vars actor_scope) - g!all_vars (|> signature (get@ #vars) (list\map code.local_identifier) (list\compose g!actor_vars)) - g!inputsC (|> signature (get@ #inputs) (list\map product.left)) - g!inputsT (|> signature (get@ #inputs) (list\map product.right)) - g!state (|> signature (get@ #state) code.local_identifier) - g!self (|> signature (get@ #self) code.local_identifier)]] + .let [g!type (code.local_identifier (value@ #abstract.name actor_scope)) + g!message (code.local_identifier (value@ #name signature)) + g!actor_vars (value@ #abstract.type_vars actor_scope) + g!all_vars (|> signature (value@ #vars) (list\map code.local_identifier) (list\compose g!actor_vars)) + g!inputsC (|> signature (value@ #inputs) (list\map product.left)) + g!inputsT (|> signature (value@ #inputs) (list\map product.right)) + g!state (|> signature (value@ #state) code.local_identifier) + g!self (|> signature (value@ #self) code.local_identifier)]] (in (list (` (def: (~ export_policy) ((~ g!message) (~+ g!inputsC)) (~ (|annotations|.format annotations)) (All [(~+ g!all_vars)] (-> (~+ g!inputsT) - (..Message (~ (get@ #abstract.abstraction actor_scope)) + (..Message (~ (value@ #abstract.abstraction actor_scope)) (~ output_type)))) (function ((~ g!_) (~ g!state) (~ g!self)) - (let [(~ g!state) (:as (~ (get@ #abstract.representation actor_scope)) + (let [(~ g!state) (:as (~ (value@ #abstract.representation actor_scope)) (~ g!state))] (|> (~ body) - (: ((~! async.Async) ((~! try.Try) [(~ (get@ #abstract.representation actor_scope)) + (: ((~! async.Async) ((~! try.Try) [(~ (value@ #abstract.representation actor_scope)) (~ output_type)]))) - (:as ((~! async.Async) ((~! try.Try) [(~ (get@ #abstract.abstraction actor_scope)) + (:as ((~! async.Async) ((~! try.Try) [(~ (value@ #abstract.abstraction actor_scope)) (~ output_type)])))))))) ))))) diff --git a/stdlib/source/library/lux/control/concurrency/async.lux b/stdlib/source/library/lux/control/concurrency/async.lux index 3dcb864b6..58fbb4ea6 100644 --- a/stdlib/source/library/lux/control/concurrency/async.lux +++ b/stdlib/source/library/lux/control/concurrency/async.lux @@ -25,8 +25,8 @@ (type: .public (Resolver a) (-> a (IO Bit))) + ... Sets an async's value if it has not been done yet. (def: (resolver async) - {#.doc "Sets an async's value if it has not been done yet."} (All [a] (-> (Async a) (Resolver a))) (function (resolve value) (let [async (:representation async)] @@ -181,14 +181,15 @@ (All [a] (-> (IO a) (Async a))) (..schedule! 0)) -(def: .public (delayed milli_seconds value) +(def: .public (after milli_seconds value) (All [a] (-> Nat a (Async a))) (..schedule! milli_seconds (io value))) (def: .public (delay milli_seconds) (-> Nat (Async Any)) - (..delayed milli_seconds [])) + (..after milli_seconds [])) -(def: .public (time_out milli_seconds async) +(def: .public (within milli_seconds async) (All [a] (-> Nat (Async a) (Async (Maybe a)))) - (..or (..delay milli_seconds) async)) + (..or (..delay milli_seconds) + async)) diff --git a/stdlib/source/library/lux/control/concurrency/frp.lux b/stdlib/source/library/lux/control/concurrency/frp.lux index e14fb6505..cb3645138 100644 --- a/stdlib/source/library/lux/control/concurrency/frp.lux +++ b/stdlib/source/library/lux/control/concurrency/frp.lux @@ -189,7 +189,7 @@ (#.Some [value ..empty])) async)) -(def: .public (fold f init channel) +(def: .public (aggregate f init channel) (All [a b] (-> (-> b a (Async a)) a (Channel b) (Async a))) @@ -202,9 +202,9 @@ (#.Some [head tail]) (do ! [init' (f head init)] - (fold f init' tail))))) + (aggregate f init' tail))))) -(def: .public (folds f init channel) +(def: .public (aggregates f init channel) (All [a b] (-> (-> b a (Async a)) a (Channel b) (Channel a))) @@ -217,7 +217,7 @@ (#.Some [head tail]) (do ! [init' (f head init)] - (in (#.Some [init (folds f init' tail)])))))) + (in (#.Some [init (aggregates f init' tail)])))))) (def: .public (poll milli_seconds action) (All [a] diff --git a/stdlib/source/library/lux/control/concurrency/semaphore.lux b/stdlib/source/library/lux/control/concurrency/semaphore.lux index c266617a5..e2cdb2aca 100644 --- a/stdlib/source/library/lux/control/concurrency/semaphore.lux +++ b/stdlib/source/library/lux/control/concurrency/semaphore.lux @@ -52,12 +52,12 @@ (async.async []))] (exec (io.run! - (with_expansions [<had_open_position?> (as_is (get@ #open_positions) (i.> -1))] + (with_expansions [<had_open_position?> (as_is (value@ #open_positions) (i.> -1))] (do io.monad - [[_ state'] (atom.update! (|>> (update@ #open_positions dec) + [[_ state'] (atom.update! (|>> (revised@ #open_positions --) (if> [<had_open_position?>] [] - [(update@ #waiting_list (queue.end sink))])) + [(revised@ #waiting_list (queue.end sink))])) semaphore)] (with_expansions [<go_ahead> (sink []) <get_in_line> (in false)] @@ -76,23 +76,23 @@ (async.future (do {! io.monad} [[pre post] (atom.update! (function (_ state) - (if (i.= (.int (get@ #max_positions state)) - (get@ #open_positions state)) + (if (i.= (.int (value@ #max_positions state)) + (value@ #open_positions state)) state (|> state - (update@ #open_positions inc) - (update@ #waiting_list queue.next)))) + (revised@ #open_positions ++) + (revised@ #waiting_list queue.next)))) semaphore)] (if (same? pre post) - (in (exception.except ..semaphore_is_maxed_out [(get@ #max_positions pre)])) + (in (exception.except ..semaphore_is_maxed_out [(value@ #max_positions pre)])) (do ! - [_ (case (queue.front (get@ #waiting_list pre)) + [_ (case (queue.front (value@ #waiting_list pre)) #.None (in true) (#.Some sink) (sink []))] - (in (#try.Success (get@ #open_positions post))))))))) + (in (#try.Success (value@ #open_positions post))))))))) ) (abstract: .public Mutex @@ -148,23 +148,23 @@ (if (n.< times step) (do async.monad [outcome (..signal! turnstile)] - (recur (inc step))) + (recur (++ step))) (\ async.monad in [])))) (template [<phase> <update> <goal> <turnstile>] [(def: (<phase> (^:representation barrier)) (-> Barrier (Async Any)) (do async.monad - [.let [limit (refinement.value (get@ #limit barrier)) + [.let [limit (refinement.value (value@ #limit barrier)) goal <goal> - [_ count] (io.run! (atom.update! <update> (get@ #count barrier))) + [_ count] (io.run! (atom.update! <update> (value@ #count barrier))) reached? (n.= goal count)]] (if reached? - (..un_block! (dec limit) (get@ <turnstile> barrier)) - (..wait! (get@ <turnstile> barrier)))))] + (..un_block! (-- limit) (value@ <turnstile> barrier)) + (..wait! (value@ <turnstile> barrier)))))] - [start! inc limit #start_turnstile] - [end! dec 0 #end_turnstile] + [start! ++ limit #start_turnstile] + [end! -- 0 #end_turnstile] ) (def: .public (block! barrier) diff --git a/stdlib/source/library/lux/control/concurrency/thread.lux b/stdlib/source/library/lux/control/concurrency/thread.lux index e067d1ac5..1011da5bb 100644 --- a/stdlib/source/library/lux/control/concurrency/thread.lux +++ b/stdlib/source/library/lux/control/concurrency/thread.lux @@ -143,8 +143,8 @@ (as_is (exception: .public cannot_continue_running_threads) ... https://en.wikipedia.org/wiki/Event_loop + ... Starts the event-loop. (def: .public run! - {#.doc (example "Starts the event-loop.")} (IO Any) (loop [_ []] (do {! io.monad} @@ -158,14 +158,14 @@ (do ! [now (\ ! map (|>> instant.millis .nat) instant.now) .let [[ready pending] (list.partition (function (_ thread) - (|> (get@ #creation thread) - (n.+ (get@ #delay thread)) + (|> (value@ #creation thread) + (n.+ (value@ #delay thread)) (n.<= now))) threads)] swapped? (atom.compare_and_swap! threads pending ..runner)] (if swapped? (do ! - [_ (monad.map ! (|>> (get@ #action) ..execute! io.io) ready)] + [_ (monad.map ! (|>> (value@ #action) ..execute! io.io) ready)] (recur [])) (panic! (exception.error ..cannot_continue_running_threads [])))) )))) diff --git a/stdlib/source/library/lux/control/exception.lux b/stdlib/source/library/lux/control/exception.lux index f89611e19..d957188ea 100644 --- a/stdlib/source/library/lux/control/exception.lux +++ b/stdlib/source/library/lux/control/exception.lux @@ -1,5 +1,4 @@ (.module: - {#.doc "Pure-Lux exception-handling functionality."} [library [lux #* ["." macro] @@ -33,7 +32,7 @@ (def: .public (match? exception error) (All [e] (-> (Exception e) Text Bit)) - (text.starts_with? (get@ #label exception) error)) + (text.starts_with? (value@ #label exception) error)) (def: .public (when exception then try) (All [e a] @@ -44,7 +43,7 @@ (#//.Success output) (#//.Failure error) - (let [reference (get@ #label exception)] + (let [reference (value@ #label exception)] (if (text.starts_with? reference error) (#//.Success (|> error (text.clip' (text.size reference)) @@ -64,7 +63,7 @@ (def: .public (error exception message) (All [e] (-> (Exception e) e Text)) - ((get@ #..constructor exception) message)) + ((value@ #..constructor exception) message)) (def: .public (except exception message) (All [e a] (-> (Exception e) e (Try a))) @@ -91,9 +90,6 @@ ))) (syntax: .public (exception: [[export_policy t_vars [name inputs] body] ..exception]) - {#.doc (example - "" - )} (macro.with_identifiers [g!descriptor] (do meta.monad [current_module meta.current_module_name @@ -102,10 +98,10 @@ (in (list (` (def: (~ export_policy) (~ g!self) (All [(~+ (list\map |type_variable|.format t_vars))] - (..Exception [(~+ (list\map (get@ #|input|.type) inputs))])) + (..Exception [(~+ (list\map (value@ #|input|.type) inputs))])) (let [(~ g!descriptor) (~ (code.text descriptor))] {#..label (~ g!descriptor) - #..constructor (function ((~ g!self) [(~+ (list\map (get@ #|input|.binding) inputs))]) + #..constructor (function ((~ g!self) [(~+ (list\map (value@ #|input|.binding) inputs))]) ((~! text\compose) (~ g!descriptor) (~ (maybe.else (' "") body))))})))))))) @@ -119,14 +115,14 @@ on_new_line (|> " " (list.repeated (n.+ (text.size header_separator) largest_header_size)) - text.joined + text.together (text\compose text.new_line)) on_entry (: (-> [Text Text] Text) (function (_ [header message]) (let [padding (|> " " (list.repeated (n.- (text.size header) largest_header_size)) - text.joined)] + text.together)] (|> message (text.replaced text.new_line on_new_line) ($_ text\compose padding header header_separator)))))] @@ -150,7 +146,7 @@ (-> (-> a Text) (List a) Text)) (|> entries (list\fold (function (_ entry [index next]) - [(inc index) + [(++ index) (#.Item [(n\encode index) (format entry)] next)]) [0 #.End]) @@ -160,7 +156,7 @@ (def: separator (let [gap ($_ "lux text concat" text.new_line text.new_line) - horizontal_line (|> "-" (list.repeated 64) text.joined)] + horizontal_line (|> "-" (list.repeated 64) text.together)] ($_ "lux text concat" gap horizontal_line diff --git a/stdlib/source/library/lux/control/function.lux b/stdlib/source/library/lux/control/function.lux index 865ea6930..11cc82e62 100644 --- a/stdlib/source/library/lux/control/function.lux +++ b/stdlib/source/library/lux/control/function.lux @@ -22,7 +22,7 @@ (-> (-> a b c) (-> b a c))) (function (_ x y) (f y x))) -(def: .public (apply input function) +(def: .public (on input function) (All [i o] (-> i (-> i o) o)) (function input)) diff --git a/stdlib/source/library/lux/control/function/contract.lux b/stdlib/source/library/lux/control/function/contract.lux index 0fb706a14..b568a7068 100644 --- a/stdlib/source/library/lux/control/function/contract.lux +++ b/stdlib/source/library/lux/control/function/contract.lux @@ -16,7 +16,7 @@ ["i" int]]]]]) (template [<name>] - [(exception: (<name> {condition Code}) + [(exception: .public (<name> {condition Code}) (exception.report ["Condition" (%.code condition)]))] @@ -32,11 +32,6 @@ (syntax: .public (pre [test <code>.any expr <code>.any]) - {#.doc (example "Pre-conditions." - "Given a test and an expression to run, only runs the expression if the test passes." - "Otherwise, an error is raised." - (pre (i.= +4 (i.+ +2 +2)) - (foo +123 +456 +789)))} (in (list (` (exec ((~! ..assert!) (~ (code.text (exception.error ..pre_condition_failed test))) (~ test)) @@ -44,12 +39,6 @@ (syntax: .public (post [test <code>.any expr <code>.any]) - {#.doc (example "Post-conditions." - "Given a predicate and an expression to run, evaluates the expression and then tests the output with the predicate." - "If the predicate returns #1, returns the value of the expression." - "Otherwise, an error is raised." - (post i.even? - (i.+ +2 +2)))} (with_identifiers [g!output] (in (list (` (let [(~ g!output) (~ expr)] (exec diff --git a/stdlib/source/library/lux/control/function/memo.lux b/stdlib/source/library/lux/control/function/memo.lux index ee20672b1..4d89e9778 100644 --- a/stdlib/source/library/lux/control/function/memo.lux +++ b/stdlib/source/library/lux/control/function/memo.lux @@ -36,7 +36,6 @@ (Recursive i (State (Dictionary i o) o))) (def: .public (open memo) - {#.doc (example "Memoization where the memoized results can be re-used accross invocations.")} (All [i o] (:let [Memory (Dictionary i o)] (-> (Memo i o) (-> [Memory i] [Memory o])))) @@ -45,8 +44,6 @@ (|> input memo (state.result memory))))) (def: .public (closed hash memo) - {#.doc (example "Memoization confined to a single invocation to the function (not counting any subsequent recursive invocations)." - "Memoized results will be re-used during recursive invocations, but cannot be accessed after the main invocation has ended.")} (All [i o] (-> (Hash i) (Memo i o) (-> i o))) (let [memo (//.mixin (//.with ..memoization (//.of_recursive memo))) @@ -54,8 +51,6 @@ (|>> memo (state.result empty) product.right))) (def: .public (none hash memo) - {#.doc (example "No memoization at all." - "This is useful as a test control when measuring the effect of using memoization.")} (All [i o] (-> (Hash i) (Memo i o) (-> i o))) (let [memo (//.mixin (//.of_recursive memo)) diff --git a/stdlib/source/library/lux/control/function/mixin.lux b/stdlib/source/library/lux/control/function/mixin.lux index cdaa35a6c..98009b21d 100644 --- a/stdlib/source/library/lux/control/function/mixin.lux +++ b/stdlib/source/library/lux/control/function/mixin.lux @@ -10,23 +10,19 @@ [monad (#+ Monad do)]]]]) (type: .public (Mixin i o) - {#.doc (example "A function which can be mixed with others to inherit their behavior.")} (-> (-> i o) (-> i o) (-> i o))) (def: .public (mixin f) - {#.doc (example "Given a mixin, produces a normal function.")} (All [i o] (-> (Mixin i o) (-> i o))) (function (mix input) ((f mix mix) input))) (def: .public nothing - {#.doc (example "A mixin that does nothing and just delegates work to the next mixin.")} Mixin (function (_ delegate recur) delegate)) (def: .public (with parent child) - {#.doc (example "Produces a new mixin, where the behavior of the child can make use of the behavior of the parent.")} (All [i o] (-> (Mixin i o) (Mixin i o) (Mixin i o))) (function (_ delegate recur) (parent (child delegate recur) recur))) @@ -38,7 +34,6 @@ (def: compose ..with)) (def: .public (advice when then) - {#.doc (example "Only apply then mixin when the input meets some criterion.")} (All [i o] (-> (Predicate i) (Mixin i o) (Mixin i o))) (function (_ delegate recur input) (if (when input) @@ -46,7 +41,6 @@ (delegate input)))) (def: .public (before monad action) - {#.doc (example "Executes an action before doing the main work.")} (All [! i o] (-> (Monad !) (-> i (! Any)) (Mixin i (! o)))) (function (_ delegate recur input) (do monad @@ -54,7 +48,6 @@ (delegate input)))) (def: .public (after monad action) - {#.doc (example "Executes an action after doing the main work.")} (All [! i o] (-> (Monad !) (-> i o (! Any)) (Mixin i (! o)))) (function (_ delegate recur input) (do monad @@ -63,11 +56,9 @@ (in output)))) (type: .public (Recursive i o) - {#.doc (example "An indirectly recursive function.")} (-> (-> i o) (-> i o))) (def: .public (of_recursive recursive) - {#.doc (example "Transform an indirectly recursive function into a mixin.")} (All [i o] (-> (Recursive i o) (Mixin i o))) (function (_ delegate recur) (recursive recur))) diff --git a/stdlib/source/library/lux/control/function/mutual.lux b/stdlib/source/library/lux/control/function/mutual.lux index fd36ac10b..dd647ce41 100644 --- a/stdlib/source/library/lux/control/function/mutual.lux +++ b/stdlib/source/library/lux/control/function/mutual.lux @@ -1,5 +1,4 @@ (.module: - {#.doc (.example "Macros for implementing mutually-recursive functions.")} [library [lux (#- Definition let def:) ["." meta] @@ -42,8 +41,8 @@ (-> (List Code) Code [Code Mutual] Code) (` (function ((~ g!name) (~ g!context)) (.let [[(~+ context)] (~ g!context)] - (function (~ (declaration.format (get@ #declaration mutual))) - (~ (get@ #body mutual))))))) + (function (~ (declaration.format (value@ #declaration mutual))) + (~ (value@ #body mutual))))))) (.def: (macro g!context g!self) (-> Code Code Macro) @@ -54,29 +53,15 @@ (syntax: .public (let [functions (<code>.tuple (<>.some ..mutual)) body <code>.any]) - {#.doc (example "Locally-defined mutually-recursive functions." - (let [(even? number) - (-> Nat Bit) - (case number - 0 true - _ (odd? (dec number))) - - (odd? number) - (-> Nat Bit) - (case number - 0 false - _ (even? (dec number)))] - (and (even? 4) - (odd? 5))))} (case functions #.End (in (list body)) (#.Item mutual #.End) - (.let [g!name (|> mutual (get@ [#declaration #declaration.name]) code.local_identifier)] - (in (list (` (.let [(~ g!name) (: (~ (get@ #type mutual)) - (function (~ (declaration.format (get@ #declaration mutual))) - (~ (get@ #body mutual))))] + (.let [g!name (|> mutual (value@ [#declaration #declaration.name]) code.local_identifier)] + (in (list (` (.let [(~ g!name) (: (~ (value@ #type mutual)) + (function (~ (declaration.format (value@ #declaration mutual))) + (~ (value@ #body mutual))))] (~ body)))))) _ @@ -89,12 +74,12 @@ (list.zipped/2 hidden_names functions)) context_types (list\map (function (_ mutual) - (` (-> (~ g!context) (~ (get@ #type mutual))))) + (` (-> (~ g!context) (~ (value@ #type mutual))))) functions) - user_names (list\map (|>> (get@ [#declaration #declaration.name]) code.local_identifier) + user_names (list\map (|>> (value@ [#declaration #declaration.name]) code.local_identifier) functions)] g!pop (local.push (list\map (function (_ [g!name mutual]) - [[here_name (get@ [#declaration #declaration.name] mutual)] + [[here_name (value@ [#declaration #declaration.name] mutual)] (..macro g!context g!name)]) (list.zipped/2 hidden_names functions)))] @@ -119,19 +104,6 @@ (<>.and (<>\in (` .private)) ..mutual)))) (syntax: .public (def: [functions (<>.many ..definition)]) - {#.doc (example "Globally-defined mutually-recursive functions." - (def: - [.public (even? number) - (-> Nat Bit) - (case number - 0 true - _ (odd? (dec number)))] - - [.public (odd? number) - (-> Nat Bit) - (case number - 0 false - _ (even? (dec number)))]))} (case functions #.End (in (list)) @@ -151,19 +123,19 @@ functions) .let [definitions (list\map (..mutual_definition hidden_names g!context) (list.zipped/2 hidden_names - (list\map (get@ #mutual) functions))) + (list\map (value@ #mutual) functions))) context_types (list\map (function (_ mutual) - (` (-> (~ g!context) (~ (get@ [#mutual #type] mutual))))) + (` (-> (~ g!context) (~ (value@ [#mutual #type] mutual))))) functions) - user_names (list\map (|>> (get@ [#mutual #declaration #declaration.name]) code.local_identifier) + user_names (list\map (|>> (value@ [#mutual #declaration #declaration.name]) code.local_identifier) functions)] g!pop (local.push (list\map (function (_ [g!name mutual]) - [[here_name (get@ [#mutual #declaration #declaration.name] mutual)] + [[here_name (value@ [#mutual #declaration #declaration.name] mutual)] (..macro g!context g!name)]) (list.zipped/2 hidden_names functions)))] (in (list& (` (.def: (~ g!context) - [(~+ (list\map (get@ [#mutual #type]) functions))] + [(~+ (list\map (value@ [#mutual #type]) functions))] (.let [(~ g!context) (: (Rec (~ g!context) [(~+ context_types)]) [(~+ definitions)]) @@ -173,11 +145,11 @@ user_names))]))) g!pop (list\map (function (_ mutual) - (.let [g!name (|> mutual (get@ [#mutual #declaration #declaration.name]) code.local_identifier)] + (.let [g!name (|> mutual (value@ [#mutual #declaration #declaration.name]) code.local_identifier)] (` (.def: - (~ (get@ #export_policy mutual)) + (~ (value@ #export_policy mutual)) (~ g!name) - (~ (get@ [#mutual #type] mutual)) + (~ (value@ [#mutual #type] mutual)) (.let [[(~+ user_names)] (~ g!context)] (~ g!name)))))) functions))))))) diff --git a/stdlib/source/library/lux/control/io.lux b/stdlib/source/library/lux/control/io.lux index 1b3b58f7b..125ebfb67 100644 --- a/stdlib/source/library/lux/control/io.lux +++ b/stdlib/source/library/lux/control/io.lux @@ -1,5 +1,4 @@ (.module: - {#.doc "A method for abstracting I/O and effectful computations to make it safe while writing pure functional code."} [library [lux #* [abstract diff --git a/stdlib/source/library/lux/control/maybe.lux b/stdlib/source/library/lux/control/maybe.lux index 74b5f06d2..7dcf84574 100644 --- a/stdlib/source/library/lux/control/maybe.lux +++ b/stdlib/source/library/lux/control/maybe.lux @@ -97,7 +97,8 @@ (All [M] (-> (Monad M) (Monad (All [a] (M (Maybe a)))))) (def: &functor - (functor.composite (get@ #monad.&functor monad) ..functor)) + (functor.composite (value@ #monad.&functor monad) + ..functor)) (def: in (|>> (\ ..monad in) (\ monad in))) diff --git a/stdlib/source/library/lux/control/parser.lux b/stdlib/source/library/lux/control/parser.lux index f4e304045..6d3246295 100644 --- a/stdlib/source/library/lux/control/parser.lux +++ b/stdlib/source/library/lux/control/parser.lux @@ -17,7 +17,6 @@ ["n" nat]]]]]) (type: .public (Parser s a) - {#.doc "A generic parser."} (-> s (Try [s a]))) (implementation: .public functor @@ -70,7 +69,6 @@ (ma input'))))) (def: .public (assertion message test) - {#.doc "Fails with the given message if the test is #0."} (All [s] (-> Text Bit (Parser s Any))) (function (_ input) (if test @@ -78,7 +76,6 @@ (#try.Failure message)))) (def: .public (maybe parser) - {#.doc "Optionality combinator."} (All [s a] (-> (Parser s a) (Parser s (Maybe a)))) (function (_ input) @@ -90,15 +87,11 @@ (#try.Success [input' (#.Some x)])))) (def: .public (result parser input) - {#.doc (example "Executes the parser on the input." - "Does not verify that all of the input has been consumed by the parser." - "Returns both the parser's output, and a value that represents the remaining input.")} (All [s a] (-> (Parser s a) s (Try [s a]))) (parser input)) (def: .public (and first second) - {#.doc "Sequencing combinator."} (All [s a b] (-> (Parser s a) (Parser s b) (Parser s [a b]))) (do {! ..monad} @@ -106,7 +99,6 @@ (\ ! map (|>> [head]) second))) (def: .public (or left right) - {#.doc "Heterogeneous alternative combinator."} (All [s a b] (-> (Parser s a) (Parser s b) (Parser s (Or a b)))) (function (_ tokens) @@ -123,7 +115,6 @@ (#try.Failure error))))) (def: .public (either this that) - {#.doc "Homogeneous alternative combinator."} (All [s a] (-> (Parser s a) (Parser s a) (Parser s a))) (function (_ tokens) @@ -135,7 +126,6 @@ output))) (def: .public (some parser) - {#.doc "0-or-more combinator."} (All [s a] (-> (Parser s a) (Parser s (List a)))) (function (_ input) @@ -149,7 +139,6 @@ input')))) (def: .public (many parser) - {#.doc "1-or-more combinator."} (All [s a] (-> (Parser s a) (Parser s (List a)))) (|> (..some parser) @@ -157,25 +146,22 @@ (\ ..monad map (|>> #.Item)))) (def: .public (exactly amount parser) - {#.doc "Parse exactly N times."} (All [s a] (-> Nat (Parser s a) (Parser s (List a)))) (case amount 0 (\ ..monad in (list)) _ (do {! ..monad} [x parser] (|> parser - (exactly (dec amount)) + (exactly (-- amount)) (\ ! map (|>> (#.Item x))))))) (def: .public (at_least amount parser) - {#.doc "Parse at least N times."} (All [s a] (-> Nat (Parser s a) (Parser s (List a)))) (do {! ..monad} [minimum (..exactly amount parser)] (\ ! map (list\compose minimum) (..some parser)))) (def: .public (at_most amount parser) - {#.doc "Parse at most N times."} (All [s a] (-> Nat (Parser s a) (Parser s (List a)))) (case amount 0 (\ ..monad in (list)) @@ -186,7 +172,7 @@ (#try.Success [input' x]) (..result (\ ..monad map (|>> (#.Item x)) - (at_most (dec amount) parser)) + (at_most (-- amount) parser)) input'))))) (def: .public (between minimum additional parser) @@ -199,7 +185,6 @@ (..at_most additional parser))))) (def: .public (separated_by separator parser) - {#.doc "Parses instances of 'parser' that are separated by instances of 'separator'."} (All [s a b] (-> (Parser s b) (Parser s a) (Parser s (List a)))) (do {! ..monad} [?x (..maybe parser)] @@ -214,7 +199,6 @@ (\ ! map (|>> (list\map product.right) (#.Item x))))))) (def: .public (not parser) - {#.doc (example "Only succeeds when the underlying parser fails.")} (All [s a] (-> (Parser s a) (Parser s Any))) (function (_ input) (case (parser input) @@ -225,13 +209,11 @@ (#try.Failure "Expected to fail; yet succeeded.")))) (def: .public (failure message) - {#.doc (example "Always fail with this 'message'.")} (All [s a] (-> Text (Parser s a))) (function (_ input) (#try.Failure message))) (def: .public (lifted operation) - {#.doc (example "Lift a potentially failed computation into a parser.")} (All [s a] (-> (Try a) (Parser s a))) (function (_ input) (case operation @@ -242,7 +224,6 @@ (#try.Failure error)))) (def: .public (else value parser) - {#.doc "If the given parser fails, returns the default value."} (All [s a] (-> a (Parser s a) (Parser s a))) (function (_ input) (case (parser input) @@ -253,26 +234,22 @@ (#try.Success [input' output])))) (def: .public remaining - {#.doc (example "Yield the remaining input (without consuming it).")} (All [s] (Parser s s)) (function (_ inputs) (#try.Success [inputs inputs]))) (def: .public (rec parser) - {#.doc "Combinator for recursive parsers."} (All [s a] (-> (-> (Parser s a) (Parser s a)) (Parser s a))) (function (_ inputs) (..result (parser (rec parser)) inputs))) (def: .public (after param subject) - {#.doc (example "Run the parser after another one (whose output is ignored).")} (All [s _ a] (-> (Parser s _) (Parser s a) (Parser s a))) (do ..monad [_ param] subject)) (def: .public (before param subject) - {#.doc (example "Run the parser before another one (whose output is ignored).")} (All [s _ a] (-> (Parser s _) (Parser s a) (Parser s a))) (do ..monad [output subject @@ -280,7 +257,6 @@ (in output))) (def: .public (only test parser) - {#.doc (example "Only succeed when the parser's output passes a test.")} (All [s a] (-> (-> a Bit) (Parser s a) (Parser s a))) (do ..monad [output parser @@ -288,7 +264,6 @@ (in output))) (def: .public (parses? parser) - {#.doc (example "Ignore a parser's output and just verify that it succeeds.")} (All [s a] (-> (Parser s a) (Parser s Bit))) (function (_ input) (case (parser input) @@ -299,7 +274,6 @@ (#try.Success [input' true])))) (def: .public (parses parser) - {#.doc (example "Ignore a parser's output and just execute it.")} (All [s a] (-> (Parser s a) (Parser s Any))) (function (_ input) (case (parser input) @@ -310,8 +284,6 @@ (#try.Success [input' []])))) (def: .public (speculative parser) - {#.doc (example "Executes a parser, without actually consuming the input." - "That way, the same input can be consumed again by another parser.")} (All [s a] (-> (Parser s a) (Parser s a))) (function (_ input) (case (parser input) @@ -322,7 +294,6 @@ output))) (def: .public (codec codec parser) - {#.doc (example "Decode the output of a parser using a codec.")} (All [s a z] (-> (Codec a z) (Parser s a) (Parser s z))) (function (_ input) (case (parser input) diff --git a/stdlib/source/library/lux/control/parser/analysis.lux b/stdlib/source/library/lux/control/parser/analysis.lux index fb32f4608..42bffc310 100644 --- a/stdlib/source/library/lux/control/parser/analysis.lux +++ b/stdlib/source/library/lux/control/parser/analysis.lux @@ -48,11 +48,9 @@ ["Input" (exception.listing /.%analysis input)])) (type: .public Parser - {#.doc (example "A parser for Lux code analysis nodes.")} (//.Parser (List Analysis))) (def: .public (result parser input) - {#.doc (example "Executes a parser and makes sure no inputs go unconsumed.")} (All [a] (-> (Parser a) (List Analysis) (Try a))) (case (parser input) (#try.Failure error) @@ -65,7 +63,6 @@ (exception.except ..unconsumed_input unconsumed))) (def: .public any - {#.doc (example "Matches any value, without discrimination.")} (Parser Analysis) (function (_ input) (case input @@ -76,7 +73,6 @@ (#try.Success [tail head])))) (def: .public end! - {#.doc "Ensures there are no more inputs."} (Parser Any) (function (_ tokens) (case tokens @@ -85,7 +81,6 @@ (remaining_inputs tokens)))))) (def: .public end? - {#.doc "Checks whether there are no more inputs."} (Parser Bit) (function (_ tokens) (#try.Success [tokens (case tokens @@ -94,7 +89,6 @@ (template [<query> <assertion> <tag> <type> <eq>] [(`` (as_is (def: .public <query> - {#.doc (example (~~ (template.text ["Queries for a " <query> " value."])))} (Parser <type>) (function (_ input) (case input @@ -105,7 +99,6 @@ (exception.except ..cannot_parse input)))) (def: .public (<assertion> expected) - {#.doc (example (~~ (template.text ["Assert a specific " <query> " value."])))} (-> <type> (Parser Any)) (function (_ input) (case input @@ -129,7 +122,6 @@ ) (def: .public (tuple parser) - {#.doc (example "Parses only within the context of a tuple's contents.")} (All [a] (-> (Parser a) (Parser a))) (function (_ input) (case input diff --git a/stdlib/source/library/lux/control/parser/binary.lux b/stdlib/source/library/lux/control/parser/binary.lux index d2d195888..ec251b304 100644 --- a/stdlib/source/library/lux/control/parser/binary.lux +++ b/stdlib/source/library/lux/control/parser/binary.lux @@ -27,11 +27,9 @@ ["." // ("#\." monad)]) (type: .public Offset - {#.doc (example "An offset for reading within binary data.")} Nat) (type: .public Parser - {#.doc (example "A parser for raw binary data.")} (//.Parser [Offset Binary])) (exception: .public (binary_was_not_fully_read {binary_length Nat} {bytes_read Nat}) @@ -40,7 +38,6 @@ ["Bytes read" (%.nat bytes_read)])) (def: .public (result parser input) - {#.doc (example "Runs a parser and checks that all the binary data was read by it.")} (All [a] (-> (Parser a) Binary (Try a))) (case (parser [0 input]) (#try.Failure msg) @@ -53,25 +50,21 @@ (exception.except ..binary_was_not_fully_read [length end]))))) (def: .public end? - {#.doc (example "Checks whether there is no more data to read.")} (Parser Bit) (function (_ (^@ input [offset data])) (#try.Success [input (n.= offset (/.size data))]))) (def: .public offset - {#.doc (example "The current offset (i.e. how much data has been read).")} (Parser Offset) (function (_ (^@ input [offset data])) (#try.Success [input offset]))) (def: .public remaining - {#.doc (example "How much of the data remains to be read.")} (Parser Nat) (function (_ (^@ input [offset data])) (#try.Success [input (n.- offset (/.size data))]))) (type: .public Size - {#.doc (example "The size of a chunk of data within a binary array.")} Nat) (def: .public size/8 Size 1) @@ -129,14 +122,12 @@ [1 #.Right right]])) (def: .public (rec body) - {#.doc (example "Tie the knot for a recursive parser.")} (All [a] (-> (-> (Parser a) (Parser a)) (Parser a))) (function (_ input) (let [parser (body (rec body))] (parser input)))) (def: .public any - {#.doc (example "Does no parsing, and just returns a dummy value.")} (Parser Any) (//\in [])) @@ -156,7 +147,6 @@ _ (//.lifted (exception.except ..not_a_bit [value]))))) (def: .public (segment size) - {#.doc (example "Parses a chunk of data of a given size.")} (-> Nat (Parser Binary)) (function (_ [offset binary]) (case size @@ -167,7 +157,6 @@ (template [<size> <name> <bits>] [(`` (def: .public <name> - {#.doc (example (~~ (template.text ["Parses a block of data prefixed with a size that is " <size> " bytes long."])))} (Parser Binary) (do //.monad [size (//\map .nat <bits>)] @@ -181,7 +170,6 @@ (template [<size> <name> <binary>] [(`` (def: .public <name> - {#.doc (example (~~ (template.text ["Parses a block of (UTF-8 encoded) text prefixed with a size that is " <size> " bytes long."])))} (Parser Text) (do //.monad [utf8 <binary>] @@ -197,7 +185,6 @@ (template [<size> <name> <bits>] [(def: .public (<name> valueP) - {#.doc (example (~~ (template.text ["Parses a row of values prefixed with a size that is " <size> " bytes long."])))} (All [v] (-> (Parser v) (Parser (Row v)))) (do //.monad [amount (: (Parser Nat) @@ -212,8 +199,8 @@ (if (n.< amount index) (do //.monad [value valueP] - (recur (.inc index) - (row.add value output))) + (recur (.++ index) + (row.suffix value output))) (//\in output)))))] [08 row/8 ..bits/8] @@ -227,7 +214,6 @@ (..or ..any)) (def: .public (list value) - {#.doc (example "Parses an arbitrarily long list of values.")} (All [a] (-> (Parser a) (Parser (List a)))) (..rec (|>> (//.and value) diff --git a/stdlib/source/library/lux/control/parser/cli.lux b/stdlib/source/library/lux/control/parser/cli.lux index 3dd50a349..d9b4928ab 100644 --- a/stdlib/source/library/lux/control/parser/cli.lux +++ b/stdlib/source/library/lux/control/parser/cli.lux @@ -11,11 +11,9 @@ ["." //]) (type: .public (Parser a) - {#.doc "A command-line interface parser."} (//.Parser (List Text) a)) (def: .public (result parser inputs) - {#.doc (example "Executes the parser and verifies that all inputs are processed.")} (All [a] (-> (Parser a) (List Text) (Try a))) (case (//.result parser inputs) (#try.Success [remaining output]) @@ -30,7 +28,6 @@ (#try.Failure try))) (def: .public any - {#.doc "Just returns the next input without applying any logic."} (Parser Text) (function (_ inputs) (case inputs @@ -41,7 +38,6 @@ (#try.Failure "Cannot parse empty arguments.")))) (def: .public (parse parser) - {#.doc "Parses the next input with a parsing function."} (All [a] (-> (-> Text (Try a)) (Parser a))) (function (_ inputs) (do try.monad @@ -50,7 +46,6 @@ (in [remaining output])))) (def: .public (this reference) - {#.doc "Checks that a token is in the inputs."} (-> Text (Parser Any)) (function (_ inputs) (do try.monad @@ -60,7 +55,6 @@ (#try.Failure (format "Missing token: '" reference "'")))))) (def: .public (somewhere cli) - {#.doc "Given a parser, tries to parse it somewhere in the inputs (i.e. not necessarily parsing the immediate inputs)."} (All [a] (-> (Parser a) (Parser a))) (function (_ inputs) (loop [immediate inputs] @@ -80,7 +74,6 @@ output]))))))) (def: .public end - {#.doc "Ensures there are no more inputs."} (Parser Any) (function (_ inputs) (case inputs @@ -88,14 +81,12 @@ _ (#try.Failure (format "Unknown parameters: " (text.interposed " " inputs)))))) (def: .public (named name value) - {#.doc (example "Parses a named parameter and yields its value.")} (All [a] (-> Text (Parser a) (Parser a))) (|> value (//.after (..this name)) ..somewhere)) (def: .public (parameter [short long] value) - {#.doc (example "Parses a parameter that can have either a short or a long name.")} (All [a] (-> [Text Text] (Parser a) (Parser a))) (|> value (//.after (//.either (..this short) (..this long))) diff --git a/stdlib/source/library/lux/control/parser/code.lux b/stdlib/source/library/lux/control/parser/code.lux index 93a2f65d9..1a3bbc5a7 100644 --- a/stdlib/source/library/lux/control/parser/code.lux +++ b/stdlib/source/library/lux/control/parser/code.lux @@ -28,7 +28,6 @@ (#.Item [[x y] pairs']) (list& x y (un_paired pairs')))) (type: .public Parser - {#.doc "A Lux code parser."} (//.Parser (List Code))) (def: remaining_inputs @@ -38,7 +37,6 @@ ($_ text\compose text.new_line "Remaining input: "))) (def: .public any - {#.doc "Yields the next input without applying any logic."} (Parser Code) (function (_ tokens) (case tokens @@ -51,7 +49,6 @@ (template [<query> <check> <type> <tag> <eq> <desc>] [(with_expansions [<failure> (as_is (#try.Failure ($_ text\compose "Cannot parse " <desc> (remaining_inputs tokens))))] (def: .public <query> - {#.doc (code.text ($_ text\compose "Parses the next " <desc> " input."))} (Parser <type>) (function (_ tokens) (case tokens @@ -62,7 +59,6 @@ <failure>))) (def: .public (<check> expected) - {#.doc (code.text ($_ text\compose "Checks for a specific " <desc> " input."))} (-> <type> (Parser Any)) (function (_ tokens) (case tokens @@ -85,7 +81,6 @@ ) (def: .public (this! code) - {#.doc "Ensures the given Code is the next input."} (-> Code (Parser Any)) (function (_ tokens) (case tokens @@ -101,7 +96,6 @@ (template [<query> <check> <tag> <eq> <desc>] [(with_expansions [<failure> (as_is (#try.Failure ($_ text\compose "Cannot parse " <desc> (remaining_inputs tokens))))] (def: .public <query> - {#.doc (code.text ($_ text\compose "Parse a local " <desc> " (a " <desc> " that has no module prefix)."))} (Parser Text) (function (_ tokens) (case tokens @@ -112,7 +106,6 @@ <failure>))) (def: .public (<check> expected) - {#.doc (code.text ($_ text\compose "Checks for a specific local " <desc> " (a " <desc> " that has no module prefix)."))} (-> Text (Parser Any)) (function (_ tokens) (case tokens @@ -130,7 +123,6 @@ (template [<name> <tag> <desc>] [(def: .public (<name> p) - {#.doc (code.text ($_ text\compose "Parses the contents of a " <desc> "."))} (All [a] (-> (Parser a) (Parser a))) (function (_ tokens) @@ -148,7 +140,6 @@ ) (def: .public (record p) - {#.doc "Parses the contents of a record."} (All [a] (-> (Parser a) (Parser a))) (function (_ tokens) @@ -162,7 +153,6 @@ (#try.Failure ($_ text\compose "Cannot parse record" (remaining_inputs tokens)))))) (def: .public end! - {#.doc "Verifies there are no more inputs."} (Parser Any) (function (_ tokens) (case tokens @@ -170,7 +160,6 @@ _ (#try.Failure ($_ text\compose "Expected list of tokens to be empty!" (remaining_inputs tokens)))))) (def: .public end? - {#.doc "Checks whether there are no more inputs."} (Parser Bit) (function (_ tokens) (#try.Success [tokens (case tokens @@ -178,7 +167,6 @@ _ false)]))) (def: .public (result parser inputs) - {#.doc (example "Executes a parser against a stream of code, and verifies all the inputs are consumed.")} (All [a] (-> (Parser a) (List Code) (Try a))) (case (parser inputs) (#try.Failure error) @@ -196,7 +184,6 @@ (text\compose "Unconsumed inputs: ")))))) (def: .public (local inputs parser) - {#.doc "Runs parser against the given list of inputs."} (All [a] (-> (List Code) (Parser a) (Parser a))) (function (_ real) (do try.monad diff --git a/stdlib/source/library/lux/control/parser/environment.lux b/stdlib/source/library/lux/control/parser/environment.lux index e12febdf3..f084a838d 100644 --- a/stdlib/source/library/lux/control/parser/environment.lux +++ b/stdlib/source/library/lux/control/parser/environment.lux @@ -13,11 +13,9 @@ ["." //]) (type: .public Property - {#.doc (example "A property in the environment.")} Text) (type: .public Environment - {#.doc (example "An abstraction for environment variables of a program.")} (Dictionary Property Text)) (exception: .public (unknown_property {property Property}) @@ -25,11 +23,9 @@ ["Property" (%.text property)])) (type: .public (Parser a) - {#.doc (example "A parser of environment variables of a program.")} (//.Parser Environment a)) (def: .public empty - {#.doc (example "An empty environment.")} Environment (dictionary.empty text.hash)) @@ -44,7 +40,5 @@ (exception.except ..unknown_property [name])))) (def: .public (result parser environment) - {#.doc (example "Executes a parser against the given environment variables." - "Does not check whether all environment variables were parsed, since they're usually an open set.")} (All [a] (-> (Parser a) Environment (Try a))) (\ try.monad map product.right (parser environment))) diff --git a/stdlib/source/library/lux/control/parser/json.lux b/stdlib/source/library/lux/control/parser/json.lux index 51c3cc2bf..65569ff9e 100644 --- a/stdlib/source/library/lux/control/parser/json.lux +++ b/stdlib/source/library/lux/control/parser/json.lux @@ -159,7 +159,7 @@ dictionary.entries (list\map (function (_ [key value]) (list (#/.String key) value))) - list.joined + list.together (//.result parser)) (#try.Failure error) (//.failure error) diff --git a/stdlib/source/library/lux/control/parser/text.lux b/stdlib/source/library/lux/control/parser/text.lux index fb2c59128..46ed6e987 100644 --- a/stdlib/source/library/lux/control/parser/text.lux +++ b/stdlib/source/library/lux/control/parser/text.lux @@ -302,7 +302,7 @@ [(def: .public (<name> parser) {#.doc (code.text ($_ /\compose "Yields " <doc_modifier> " characters as a single continuous text (as a slice)."))} (-> (Parser Text) (Parser Text)) - (|> parser <base> (\ //.monad map /.joined)))] + (|> parser <base> (\ //.monad map /.together)))] [some //.some "some"] [many //.many "many"] @@ -324,7 +324,7 @@ (-> Nat (Parser Text) (Parser Text)) (|> parser (<base> amount) - (\ //.monad map /.joined)))] + (\ //.monad map /.together)))] [exactly //.exactly "exactly"] [at_most //.at_most "at most"] @@ -347,7 +347,7 @@ (-> Nat Nat (Parser Text) (Parser Text)) (|> parser (//.between minimum additional) - (\ //.monad map /.joined))) + (\ //.monad map /.together))) (def: .public (between! minimum additional parser) (-> Nat Nat (Parser Slice) (Parser Slice)) diff --git a/stdlib/source/library/lux/control/parser/type.lux b/stdlib/source/library/lux/control/parser/type.lux index 8016080b5..e6ea2b3dd 100644 --- a/stdlib/source/library/lux/control/parser/type.lux +++ b/stdlib/source/library/lux/control/parser/type.lux @@ -197,19 +197,19 @@ all_varsL (: (List Code) (list))] (if (n.< num_args current_arg) (if (n.= 0 current_arg) - (let [varL (label (inc funcI))] - (recur (inc current_arg) + (let [varL (label (++ funcI))] + (recur (++ current_arg) (|> env' (dictionary.has funcI [headT funcL]) - (dictionary.has (inc funcI) [(#.Parameter (inc funcI)) varL])) + (dictionary.has (++ funcI) [(#.Parameter (++ funcI)) varL])) (#.Item varL all_varsL))) (let [partialI (|> current_arg (n.* 2) (n.+ funcI)) - partial_varI (inc partialI) + partial_varI (++ partialI) partial_varL (label partial_varI) partialC (` ((~ funcL) (~+ (|> (list.indices num_args) - (list\map (|>> (n.* 2) inc (n.+ funcI) label)) + (list\map (|>> (n.* 2) ++ (n.+ funcI) label)) list.reversed))))] - (recur (inc current_arg) + (recur (++ current_arg) (|> env' (dictionary.has partialI [.Nothing partialC]) (dictionary.has partial_varI [(#.Parameter partial_varI) partial_varL])) @@ -265,7 +265,7 @@ (let [env_level (n./ 2 (dictionary.size env)) parameter_level (n./ 2 idx) parameter_idx (n.% 2 idx)] - (|> env_level dec (n.- parameter_level) (n.* 2) (n.+ parameter_idx)))) + (|> env_level -- (n.- parameter_level) (n.* 2) (n.+ parameter_idx)))) (def: .public parameter (Parser Code) diff --git a/stdlib/source/library/lux/control/pipe.lux b/stdlib/source/library/lux/control/pipe.lux index 66d3f2a06..b194d6749 100644 --- a/stdlib/source/library/lux/control/pipe.lux +++ b/stdlib/source/library/lux/control/pipe.lux @@ -27,21 +27,11 @@ (syntax: .public (new> [start <code>.any body body^ prev <code>.any]) - {#.doc (example "Ignores the piped argument, and begins a new pipe." - (n.= 1 - (|> 20 - (n.* 3) - (n.+ 4) - (new> 0 [inc]))))} (in (list (` (|> (~ start) (~+ body)))))) (syntax: .public (let> [binding <code>.any body <code>.any prev <code>.any]) - {#.doc (example "Gives a name to the piped-argument, within the given expression." - (n.= 10 - (|> 5 - (let> x (n.+ x x)))))} (in (list (` (let [(~ binding) (~ prev)] (~ body)))))) @@ -55,12 +45,6 @@ else body^ _ _reversed_ branches (<>.some (<>.and body^ body^))]) - {#.doc (example "Branching for pipes." - "Both the tests and the bodies are piped-code, and must be given inside a tuple." - (|> +5 - (cond> [i.even?] [(i.* +2)] - [i.odd?] [(i.* +3)] - [(new> -1 [])])))} (with_identifiers [g!temp] (in (list (` (let [(~ g!temp) (~ prev)] (cond (~+ (do list.monad @@ -73,14 +57,6 @@ then body^ else body^ prev <code>.any]) - {#.doc (example "If-branching." - (same? (if (n.even? sample) - "even" - "odd") - (|> sample - (if> [n.even?] - [(new> "even" [])] - [(new> "odd" [])]))))} (in (list (` (cond> [(~+ test)] [(~+ then)] [(~+ else)] (~ prev)))))) @@ -88,13 +64,6 @@ (syntax: .public (when> [test body^ then body^ prev <code>.any]) - {#.doc (example "Only execute the body when the test passes." - (same? (if (n.even? sample) - (n.* 2 sample) - sample) - (|> sample - (when> [n.even?] - [(n.* 2)]))))} (in (list (` (cond> [(~+ test)] [(~+ then)] [] (~ prev)))))) @@ -102,11 +71,6 @@ (syntax: .public (loop> [test body^ then body^ prev <code>.any]) - {#.doc (example "Loops for pipes." - "Both the testing and calculating steps are pipes and must be given inside tuples." - (|> +1 - (loop> [(i.< +10)] - [inc])))} (with_identifiers [g!temp] (in (list (` (loop [(~ g!temp) (~ prev)] (if (|> (~ g!temp) (~+ test)) @@ -116,13 +80,6 @@ (syntax: .public (do> [monad <code>.any steps (<>.some body^) prev <code>.any]) - {#.doc (example "Monadic pipes." - "Each steps in the monadic computation is a pipe and must be given inside a tuple." - (|> +5 - (do> identity.monad - [(i.* +3)] - [(i.+ +4)] - [inc])))} (with_identifiers [g!temp] (case (list.reversed steps) (^ (list& last_step prev_steps)) @@ -139,11 +96,6 @@ (syntax: .public (exec> [body body^ prev <code>.any]) - {#.doc (example "Non-updating pipes." - "Will generate piped computations, but their results will not be used in the larger scope." - (|> +5 - (exec> [.nat %n log!]) - (i.* +10)))} (with_identifiers [g!temp] (in (list (` (let [(~ g!temp) (~ prev)] (exec (|> (~ g!temp) (~+ body)) @@ -151,13 +103,6 @@ (syntax: .public (tuple> [paths (<>.many body^) prev <code>.any]) - {#.doc (example "Parallel branching for pipes." - "Allows to run multiple pipelines for a value and gives you a tuple of the outputs." - (|> +5 - (tuple> [(i.* +10)] - [dec (i./ +2)] - [Int/encode])) - "Will become: [+50 +2 '+5']")} (with_identifiers [g!temp] (in (list (` (let [(~ g!temp) (~ prev)] [(~+ (list\map (function (_ body) (` (|> (~ g!temp) (~+ body)))) @@ -165,20 +110,6 @@ (syntax: .public (case> [branches (<>.many (<>.and <code>.any <code>.any)) prev <code>.any]) - {#.doc (example "Pattern-matching for pipes." - "The bodies of each branch are NOT pipes; just regular values." - (|> +5 - (case> +0 "zero" - +1 "one" - +2 "two" - +3 "three" - +4 "four" - +5 "five" - +6 "six" - +7 "seven" - +8 "eight" - +9 "nine" - _ "???")))} (in (list (` (case (~ prev) (~+ (list\join (list\map (function (_ [pattern body]) (list pattern body)) branches)))))))) diff --git a/stdlib/source/library/lux/control/reader.lux b/stdlib/source/library/lux/control/reader.lux index 09fcd2058..e1ffffd7b 100644 --- a/stdlib/source/library/lux/control/reader.lux +++ b/stdlib/source/library/lux/control/reader.lux @@ -7,21 +7,17 @@ ["." monad (#+ Monad do)]]]]) (type: .public (Reader r a) - {#.doc "Computations that have access to some environmental value."} (-> r a)) (def: .public read - {#.doc "Get the environment."} (All [r] (Reader r r)) (function (_ env) env)) (def: .public (local change proc) - {#.doc "Run computation with a locally-modified environment."} (All [r a] (-> (-> r r) (Reader r a) (Reader r a))) (|>> change proc)) (def: .public (result env proc) - {#.doc "Executes the reader against the given environment."} (All [r a] (-> r (Reader r a) a)) (proc env)) @@ -54,11 +50,10 @@ (mma env env)))) (implementation: .public (with monad) - {#.doc "Monad transformer for Reader."} (All [M] (-> (Monad M) (All [e] (Monad (All [a] (Reader e (M a))))))) (def: &functor - (functor.composite ..functor (get@ #monad.&functor monad))) + (functor.composite ..functor (value@ #monad.&functor monad))) (def: in (|>> (\ monad in) (\ ..monad in))) @@ -70,6 +65,5 @@ (result env eMa))))) (def: .public lifted - {#.doc "Lift monadic values to the Reader wrapper."} (All [M e a] (-> (M a) (Reader e (M a)))) (\ ..monad in)) diff --git a/stdlib/source/library/lux/control/region.lux b/stdlib/source/library/lux/control/region.lux index 191c6a328..9d9f579c0 100644 --- a/stdlib/source/library/lux/control/region.lux +++ b/stdlib/source/library/lux/control/region.lux @@ -19,8 +19,6 @@ (-> r (! (Try Any)))) (type: .public (Region r ! a) - {#.doc (example "A region where resources may be be claimed and where a side-effecting computation may be performed." - "Every resource is paired with a function that knows how to clean/reclaim it, to make sure there are no leaks.")} (-> [r (List (Cleaner r !))] (! [(List (Cleaner r !)) (Try a)]))) @@ -54,7 +52,6 @@ (exception.except ..clean_up_error [error output]))) (def: .public (run! monad computation) - {#.doc (example "Executes a region-based computation, with a side-effect determined by the monad.")} (All [! a] (-> (Monad !) (All [r] (Region r ! a)) (! (Try a)))) @@ -65,7 +62,6 @@ (\ ! map (list\fold clean output))))) (def: .public (acquire! monad cleaner value) - {#.doc (example "Acquire a resource while pairing it a function that knows how to reclaim it.")} (All [! a] (-> (Monad !) (-> a (! (Try Any))) a (All [r] (Region r ! a)))) (function (_ [region cleaners]) @@ -97,7 +93,7 @@ (All [r] (Apply (Region r !))))) (def: &functor - (..functor (get@ #monad.&functor super))) + (..functor (value@ #monad.&functor super))) (def: (apply ff fa) (function (_ [region cleaners]) @@ -122,7 +118,7 @@ (All [r] (Monad (Region r !))))) (def: &functor - (..functor (get@ #monad.&functor super))) + (..functor (value@ #monad.&functor super))) (def: (in value) (function (_ [region cleaners]) @@ -140,7 +136,6 @@ (in [cleaners (#try.Failure error)])))))) (def: .public (failure monad error) - {#.doc (example "Immediately fail with this 'message'.")} (All [! a] (-> (Monad !) Text (All [r] (Region r ! a)))) @@ -148,14 +143,12 @@ (\ monad in [cleaners (#try.Failure error)]))) (def: .public (except monad exception message) - {#.doc (example "Fail by throwing/raising an exception.")} (All [! e a] (-> (Monad !) (Exception e) e (All [r] (Region r ! a)))) (failure monad (exception.error exception message))) (def: .public (lifted monad operation) - {#.doc (example "Lift an effectful computation into a region-based computation.")} (All [! a] (-> (Monad !) (! a) (All [r] (Region r ! a)))) diff --git a/stdlib/source/library/lux/control/remember.lux b/stdlib/source/library/lux/control/remember.lux index 25b595b63..9c6e7a97e 100644 --- a/stdlib/source/library/lux/control/remember.lux +++ b/stdlib/source/library/lux/control/remember.lux @@ -50,13 +50,6 @@ (syntax: .public (remember [deadline ..deadline message <c>.text focus (<>.maybe <c>.any)]) - {#.doc (example "A message with an expiration date." - "Can have an optional piece of code to focus on." - (remember "2022-04-01" - "Do this, that and the other.") - (remember "2022-04-01" - "Improve the performace." - (some (complicated (computation 123)))))} (let [now (io.run! instant.now) today (instant.date now)] (if (date\< deadline today) diff --git a/stdlib/source/library/lux/control/security/capability.lux b/stdlib/source/library/lux/control/security/capability.lux index 3762c6e8f..45b2bd083 100644 --- a/stdlib/source/library/lux/control/security/capability.lux +++ b/stdlib/source/library/lux/control/security/capability.lux @@ -25,8 +25,7 @@ ["|.|" annotations]]]]]) (abstract: .public (Capability brand input output) - {#.doc (example "Represents the capability to perform an operation." - "This operation is assumed to have security implications.")} + {} (-> input output) @@ -37,7 +36,6 @@ (|>> :abstraction)) (def: .public (use capability input) - {#.doc (example "Applies a capability against its required input.")} (All [brand input output] (-> (Capability brand input output) input @@ -50,16 +48,6 @@ |declaration|.parser (<>.maybe |annotations|.parser) (<c>.form ($_ <>.and <c>.local_identifier <c>.any <c>.any))))]) - {#.doc (example "Defines a capability as a unique type, and a constructor for instances." - - (capability: (Can_Duplicate a) - (can_duplicate a [a a])) - - (let [capability (can_duplicate - (function (_ value) - [value value])) - [left right] (..use capability 123)] - (same? left right)))} (do {! meta.monad} [this_module meta.current_module_name .let [[name vars] declaration] @@ -77,7 +65,6 @@ )))) (def: .public (async capability) - {#.doc (example "Converts a synchronous I/O-based capability into an asynchronous capability.")} (All [brand input output] (-> (Capability brand input (IO output)) (Capability brand input (Async output)))) diff --git a/stdlib/source/library/lux/control/security/policy.lux b/stdlib/source/library/lux/control/security/policy.lux index ea47056bd..9e33fa86b 100644 --- a/stdlib/source/library/lux/control/security/policy.lux +++ b/stdlib/source/library/lux/control/security/policy.lux @@ -9,38 +9,32 @@ abstract]]]) (abstract: .public (Policy brand value label) - {#.doc (example "A security policy encoded as the means to 'upgrade' or 'downgrade' in a secure context.")} + {} value (type: .public (Can_Upgrade brand label value) - {#.doc (example "Represents the capacity to 'upgrade' a value.")} (-> value (Policy brand value label))) (type: .public (Can_Downgrade brand label value) - {#.doc (example "Represents the capacity to 'downgrade' a value.")} (-> (Policy brand value label) value)) (type: .public (Privilege brand label) - {#.doc (example "Represents the privilege to both 'upgrade' and 'downgrade' a value.")} {#can_upgrade (Can_Upgrade brand label) #can_downgrade (Can_Downgrade brand label)}) (type: .public (Delegation brand from to) - {#.doc (example "Represents the act of delegating policy capacities.")} (All [value] (-> (Policy brand value from) (Policy brand value to)))) (def: .public (delegation downgrade upgrade) - {#.doc (example "Delegating policy capacities.")} (All [brand from to] (-> (Can_Downgrade brand from) (Can_Upgrade brand to) (Delegation brand from to))) (|>> downgrade upgrade)) (type: .public (Context brand scope label) - {#.doc (example "A computational context with an associated policy privilege.")} (-> (Privilege brand label) (scope label))) @@ -50,27 +44,6 @@ #can_downgrade (|>> :representation)}) (def: .public (with_policy context) - {#.doc (example "Activates a security context with the priviledge to enforce it's policy." - - (type: Password - (Private Text)) - - (interface: (Policy %) - (: (-> Text (Password %)) - password) - (: (-> (Password %) Text) - unsafe)) - - (def: (policy _) - (Ex [%] (-> Any (Policy %))) - (with_policy - (: (Context Privacy Policy) - (function (_ (^open "%::.")) - (implementation - (def: (password value) - (%::can_upgrade value)) - (def: (unsafe password) - (%::can_downgrade password))))))))} (All [brand scope] (Ex [label] (-> (Context brand scope label) @@ -104,9 +77,9 @@ (def: join (|>> :representation))) ) -(template [<brand> <value> <upgrade> <downgrade> <doc>] +(template [<brand> <value> <upgrade> <downgrade>] [(abstract: .public <brand> - {#.doc <doc>} + {} Any @@ -120,10 +93,6 @@ (Can_Downgrade <brand>)) )] - [Privacy Private Can_Conceal Can_Reveal - (example "A security context for privacy." - "Private data is data which cannot be allowed to leak outside of the programmed.")] - [Safety Safe Can_Trust Can_Distrust - (example "A security context for safety." - "Safe data is data coming from outside the program which can be trusted to be properly formatted and lacking injections.")] + [Privacy Private Can_Conceal Can_Reveal] + [Safety Safe Can_Trust Can_Distrust] ) diff --git a/stdlib/source/library/lux/control/state.lux b/stdlib/source/library/lux/control/state.lux index 470751832..109491fee 100644 --- a/stdlib/source/library/lux/control/state.lux +++ b/stdlib/source/library/lux/control/state.lux @@ -7,42 +7,35 @@ [monad (#+ Monad do)]]]]) (type: .public (State s a) - {#.doc "Stateful computations."} (-> s [s a])) (def: .public get - {#.doc "Read the current state."} (All [s] (State s s)) (function (_ state) [state state])) (def: .public (put new_state) - {#.doc "Set the new state."} (All [s] (-> s (State s Any))) (function (_ state) [new_state []])) (def: .public (update change) - {#.doc "Compute the new state."} (All [s] (-> (-> s s) (State s Any))) (function (_ state) [(change state) []])) (def: .public (use user) - {#.doc "Run a function on the current state."} (All [s a] (-> (-> s a) (State s a))) (function (_ state) [state (user state)])) (def: .public (local change action) - {#.doc "Run the computation with a locally-modified state."} (All [s a] (-> (-> s s) (State s a) (State s a))) (function (_ state) (let [[state' output] (action (change state))] [state output]))) (def: .public (result state action) - {#.doc "Run a stateful computation."} (All [s a] (-> s (State s a) [s a])) (action state)) @@ -80,7 +73,6 @@ (ma state'))))) (def: .public (while condition body) - {#.doc (example "A stateful while loop.")} (All [s] (-> (State s Bit) (State s Any) (State s Any))) (do {! ..monad} [execute? condition] @@ -91,7 +83,6 @@ (in [])))) (def: .public (do_while condition body) - {#.doc (example "A stateful do-while loop.")} (All [s] (-> (State s Bit) (State s Any) (State s Any))) (do ..monad [_ body] @@ -118,16 +109,13 @@ (in [state (f a)]))))) (type: .public (+State M s a) - {#.doc "Stateful computations decorated by a monad."} (-> s (M [s a]))) (def: .public (result' state action) - {#.doc "Execute a stateful computation decorated by a monad."} (All [M s a] (-> s (+State M s a) (M [s a]))) (action state)) (implementation: .public (with monad) - {#.doc "A monad transformer to create composite stateful computations."} (All [M s] (-> (Monad M) (Monad (+State M s)))) (def: &functor (with//functor (\ monad &functor))) @@ -143,7 +131,6 @@ (sMa state'))))) (def: .public (lifted monad ma) - {#.doc "Lift monadic values to the +State wrapper."} (All [M s a] (-> (Monad M) (M a) (+State M s a))) (function (_ state) (do monad diff --git a/stdlib/source/library/lux/control/thread.lux b/stdlib/source/library/lux/control/thread.lux index 266c12afc..b70813ec9 100644 --- a/stdlib/source/library/lux/control/thread.lux +++ b/stdlib/source/library/lux/control/thread.lux @@ -15,16 +15,14 @@ abstract]]]) (type: .public (Thread ! a) - {#.doc (example "An imperative process with access to mutable values.")} (-> ! a)) (abstract: .public (Box t v) - {#.doc "A mutable box holding a value."} + {} (Array v) (def: .public (box init) - {#.doc (example "A brand-new box initialized to the given value.")} (All [a] (-> a (All [!] (Thread ! (Box ! a))))) (function (_ !) (|> (array.empty 1) @@ -32,7 +30,6 @@ :abstraction))) (def: .public (read! box) - {#.doc (example "Reads the current value in the box.")} (All [! a] (-> (Box ! a) (Thread ! a))) (function (_ !) (for {@.old @@ -54,21 +51,18 @@ @.scheme ("scheme array read" 0 (:representation box))}))) (def: .public (write! value box) - {#.doc (example "Mutates the value in the box.")} (All [a] (-> a (All [!] (-> (Box ! a) (Thread ! Any))))) (function (_ !) (|> box :representation (array.write! 0 value) :abstraction))) ) (def: .public (result thread) - {#.doc (example "Executes the imperative thread in a self-contained way.")} (All [a] (-> (All [!] (Thread ! a)) a)) (thread [])) (def: .public io - {#.doc (example "Transforms the imperative thread into an I/O computation.")} (All [a] (-> (All [!] (Thread ! a)) (IO a))) @@ -105,7 +99,6 @@ ((ffa !) !)))) (def: .public (update! f box) - {#.doc (example "Update a box's value by applying a function to it.")} (All [a !] (-> (-> a a) (Box ! a) (Thread ! a))) (do ..monad [old (read! box) diff --git a/stdlib/source/library/lux/control/try.lux b/stdlib/source/library/lux/control/try.lux index c7dc9f1d9..05d7d69ea 100644 --- a/stdlib/source/library/lux/control/try.lux +++ b/stdlib/source/library/lux/control/try.lux @@ -10,7 +10,6 @@ ["." location]]]]) (type: .public (Try a) - {#.doc (example "A computation that can fail with an error message.")} (#Failure Text) (#Success a)) @@ -60,12 +59,11 @@ ma))) (implementation: .public (with monad) - {#.doc (example "Enhances a monad with error-handling functionality.")} ... TODO: Replace (All [a] (! (Try a))) with (functor.Then ! Try) (All [!] (-> (Monad !) (Monad (All [a] (! (Try a)))))) (def: &functor - (functor.composite (get@ #monad.&functor monad) ..functor)) + (functor.composite (value@ #monad.&functor monad) ..functor)) (def: in (|>> (\ ..monad in) @@ -82,7 +80,6 @@ Mea)))) (def: .public (lifted monad) - {#.doc (example "Wraps a monadic value with error-handling machinery.")} (All [! a] (-> (Monad !) (-> (! a) (! (Try a))))) (\ monad map (\ ..monad in))) @@ -102,9 +99,6 @@ ))) (def: .public (trusted try) - {#.doc (example "Assumes a Try value succeeded, and yields its value." - "If it didn't, raises the error as a runtime error." - "WARNING: Use with caution.")} (All [a] (-> (Try a) a)) (case try (#Success value) @@ -133,13 +127,6 @@ (name_of ..of_maybe)))))) (macro: .public (else tokens compiler) - {#.doc (example "Allows you to provide a default value that will be used" - "if a (Try x) value turns out to be #Failure." - "Note: the expression for the default value will not be computed if the base computation succeeds." - (= "bar" - (else "foo" (#..Success "bar"))) - (= "foo" - (else "foo" (#..Failure "KABOOM!"))))} (case tokens (^ (list else try)) (#Success [compiler (list (` (case (~ try) diff --git a/stdlib/source/library/lux/control/writer.lux b/stdlib/source/library/lux/control/writer.lux index 18a0fc7e1..194822f60 100644 --- a/stdlib/source/library/lux/control/writer.lux +++ b/stdlib/source/library/lux/control/writer.lux @@ -9,12 +9,10 @@ ["." monad (#+ Monad do)]]]]) (type: .public (Writer log value) - {#.doc "Represents a value with an associated 'log' to record arbitrary information."} {#log log #value value}) (def: .public (write message) - {#.doc "Write a value to the log."} (All [log] (-> log (Writer log Any))) [message []]) @@ -51,11 +49,10 @@ [(\ monoid compose log1 log2) a]))) (implementation: .public (with monoid monad) - {#.doc (example "Enhances a monad with Writer functionality.")} (All [l M] (-> (Monoid l) (Monad M) (Monad (All [a] (M (Writer l a)))))) (def: &functor - (functor.composite (get@ #monad.&functor monad) + (functor.composite (value@ #monad.&functor monad) ..functor)) (def: in @@ -73,7 +70,6 @@ (in [(\ monoid compose l1 l2) a])))) (def: .public (lifted monoid monad) - {#.doc (example "Wraps a monadic value with Writer machinery.")} (All [l M a] (-> (Monoid l) (Monad M) (-> (M a) (M (Writer l a))))) diff --git a/stdlib/source/library/lux/data/binary.lux b/stdlib/source/library/lux/data/binary.lux index cff9714e2..13b9b5a9d 100644 --- a/stdlib/source/library/lux/data/binary.lux +++ b/stdlib/source/library/lux/data/binary.lux @@ -102,8 +102,8 @@ (array.Array (I64 Any))))) (template: (!size binary) - [(for {@.old (ffi.array_length binary) - @.jvm (ffi.array_length binary) + [(for {@.old (ffi.length binary) + @.jvm (ffi.length binary) @.js (|> binary @@ -122,8 +122,8 @@ (array.size binary))]) (template: (!read index binary) - [(for {@.old (..i64 (ffi.array_read index binary)) - @.jvm (..i64 (ffi.array_read index binary)) + [(for {@.old (..i64 (ffi.read! index binary)) + @.jvm (..i64 (ffi.read! index binary)) @.js (|> binary @@ -155,8 +155,8 @@ (:as ..Binary))]) (template: (!write index value binary) - [(for {@.old (ffi.array_write index (..byte value) binary) - @.jvm (ffi.array_write index (..byte value) binary) + [(for {@.old (ffi.write! index (..byte value) binary) + @.jvm (ffi.write! index (..byte value) binary) @.js (!!write .Frac n.frac "js array write" index value binary) @.python (!!write (I64 Any) (:as (I64 Any)) "python array write" index value binary) @@ -190,13 +190,13 @@ ... Default (array.empty size))) -(def: .public (fold f init binary) +(def: .public (aggregate f init binary) (All [a] (-> (-> I64 a a) a Binary a)) (let [size (..!size binary)] (loop [index 0 output init] (if (n.< size index) - (recur (inc index) (f (!read index binary) output)) + (recur (++ index) (f (!read index binary) output)) output)))) (def: .public (read/8! index binary) @@ -307,7 +307,7 @@ (if (n.< limit index) (and (n.= (!read index reference) (!read index sample)) - (recur (inc index))) + (recur (++ index))) true)))))))) (for {@.old (as_is) @@ -341,7 +341,7 @@ (exec (!write (n.+ target_offset index) (!read (n.+ source_offset index) source) target) - (recur (inc index))) + (recur (++ index))) (#try.Success target)))))))) (def: .public (slice offset length binary) diff --git a/stdlib/source/library/lux/data/collection/array.lux b/stdlib/source/library/lux/data/collection/array.lux index 5d306f773..ae6aa7b96 100644 --- a/stdlib/source/library/lux/data/collection/array.lux +++ b/stdlib/source/library/lux/data/collection/array.lux @@ -205,7 +205,7 @@ count (#.Some _) - (inc count))) + (++ count))) 0 (list.indices (size array)))) @@ -239,12 +239,12 @@ (if (n.< arr_size idx) (case (read! idx xs) #.None - (recur (inc idx)) + (recur (++ idx)) (#.Some x) (if (p x) (#.Some x) - (recur (inc idx)))) + (recur (++ idx)))) #.None)))) (def: .public (example+ p xs) @@ -256,12 +256,12 @@ (if (n.< arr_size idx) (case (read! idx xs) #.None - (recur (inc idx)) + (recur (++ idx)) (#.Some x) (if (p idx x) (#.Some [idx x]) - (recur (inc idx)))) + (recur (++ idx)))) #.None)))) (def: .public (clone xs) @@ -281,25 +281,25 @@ (def: .public (of_list xs) (All [a] (-> (List a) (Array a))) (product.right (list\fold (function (_ x [idx arr]) - [(inc idx) (write! idx x arr)]) + [(++ idx) (write! idx x arr)]) [0 (empty (list.size xs))] xs))) (def: underflow Nat - (dec 0)) + (-- 0)) (def: .public (list array) {#.doc (.example "Yields a list with every non-empty item in the array.")} (All [a] (-> (Array a) (List a))) - (loop [idx (dec (size array)) + (loop [idx (-- (size array)) output #.End] (case idx (^ (static ..underflow)) output _ - (recur (dec idx) + (recur (-- idx) (case (read! idx array) (#.Some head) (#.Item head output) @@ -310,14 +310,14 @@ (def: .public (list' default array) {#.doc (.example "Like 'list', but uses the 'default' value when encountering an empty cell in the array.")} (All [a] (-> a (Array a) (List a))) - (loop [idx (dec (size array)) + (loop [idx (-- (size array)) output #.End] (case idx (^ (static ..underflow)) output _ - (recur (dec idx) + (recur (-- idx) (#.Item (maybe.else default (read! idx array)) output))))) @@ -382,10 +382,10 @@ (if (n.< arr_size idx) (case (read! idx xs) #.None - (recur so_far (inc idx)) + (recur so_far (++ idx)) (#.Some value) - (recur (f value so_far) (inc idx))) + (recur (f value so_far) (++ idx))) so_far))))) (template [<name> <init> <op>] @@ -399,10 +399,10 @@ (case (..read! idx array) (#.Some value) (<op> (predicate value) - (recur (inc idx))) + (recur (++ idx))) #.None - (recur (inc idx))) + (recur (++ idx))) <init>)))))] [every? true and] diff --git a/stdlib/source/library/lux/data/collection/bits.lux b/stdlib/source/library/lux/data/collection/bits.lux index e5e85e361..b5059ea8a 100644 --- a/stdlib/source/library/lux/data/collection/bits.lux +++ b/stdlib/source/library/lux/data/collection/bits.lux @@ -66,10 +66,10 @@ [(def: .public (<name> index input) (-> Nat Bits Bits) (let [[chunk_index bit_index] (n./% chunk_size index)] - (loop [size|output (n.max (inc chunk_index) + (loop [size|output (n.max (++ chunk_index) (array.size input)) output ..empty] - (let [idx|output (dec size|output)] + (let [idx|output (-- size|output)] (if (n.> 0 size|output) (case (|> (..chunk idx|output input) (cond> [(new> (n.= chunk_index idx|output) [])] @@ -80,7 +80,7 @@ .nat) 0 ... TODO: Remove 'no_op' once new-luxc is the official compiler. - (let [no_op (recur (dec size|output) output)] + (let [no_op (recur (-- size|output) output)] no_op) chunk @@ -88,7 +88,7 @@ (: Bits (array.empty size|output)) output) (array.write! idx|output (.i64 chunk)) - (recur (dec size|output)))) + (recur (-- size|output)))) output)))))] [one i64.one] @@ -106,7 +106,7 @@ (i64.and (..chunk idx reference)) ("lux i64 =" empty_chunk) .not) - (recur (inc idx))) + (recur (++ idx))) #0)))) (def: .public (not input) @@ -118,10 +118,10 @@ size|output (loop [size|output size|output output ..empty] - (let [idx (dec size|output)] + (let [idx (-- size|output)] (case (|> input (..chunk idx) i64.not .nat) 0 - (recur (dec size|output) output) + (recur (-- size|output) output) chunk (if (n.> 0 size|output) @@ -129,7 +129,7 @@ (: Bits (array.empty size|output)) output) (array.write! idx (.i64 chunk)) - (recur (dec size|output))) + (recur (-- size|output))) output)))))) (template [<name> <op>] @@ -143,20 +143,20 @@ size|output (loop [size|output size|output output ..empty] - (let [idx (dec size|output)] + (let [idx (-- size|output)] (if (n.> 0 size|output) (case (|> (..chunk idx subject) (<op> (..chunk idx param)) .nat) 0 - (recur (dec size|output) output) + (recur (-- size|output) output) chunk (|> (if (same? ..empty output) (: Bits (array.empty size|output)) output) (array.write! idx (.i64 chunk)) - (recur (dec size|output)))) + (recur (-- size|output)))) output)))))] [and i64.and] @@ -175,5 +175,5 @@ (.and ("lux i64 =" (..chunk idx reference) (..chunk idx sample)) - (recur (inc idx))) + (recur (++ idx))) #1))))) diff --git a/stdlib/source/library/lux/data/collection/dictionary.lux b/stdlib/source/library/lux/data/collection/dictionary.lux index fb7aaaa83..6773a3b95 100644 --- a/stdlib/source/library/lux/data/collection/dictionary.lux +++ b/stdlib/source/library/lux/data/collection/dictionary.lux @@ -133,10 +133,10 @@ (def: (array\has idx value old_array) (All [a] (-> Index a (Array a) (Array a))) (let [old_size (array.size old_array)] - (|> (array.empty (inc old_size)) + (|> (array.empty (++ old_size)) (array.copy! idx 0 old_array 0) (array.write! idx value) - (array.copy! (n.- idx old_size) idx old_array (inc idx))))) + (array.copy! (n.- idx old_size) idx old_array (++ idx))))) ... Creates a copy of an array with an index set to a particular value. (def: (array\revised idx value array) @@ -151,10 +151,10 @@ ... Shrinks a copy of the array by removing the space at index. (def: (array\lacks idx array) (All [a] (-> Index (Array a) (Array a))) - (let [new_size (dec (array.size array))] + (let [new_size (-- (array.size array))] (|> (array.empty new_size) (array.copy! idx 0 array 0) - (array.copy! (n.- idx new_size) (inc idx) array idx)))) + (array.copy! (n.- idx new_size) (++ idx) array idx)))) ... Increases the level-shift by the branching-exponent, to explore ... levels further down the tree. @@ -164,7 +164,7 @@ (def: hierarchy_mask Bit_Map - (dec hierarchy_nodes_size)) + (-- hierarchy_nodes_size)) ... Gets the branching-factor sized section of the hash corresponding ... to a particular level, and uses that as an index into the array. @@ -214,7 +214,7 @@ ... associated with it. (def: bit_position_mask (-> Bit_Position Bit_Map) - dec) + --) ... The index on the base array, based on its bit-position. (def: (base_index bit_position bitmap) @@ -240,12 +240,12 @@ #.None [insertion_idx node] (#.Some sub_node) (if (n.= except_idx idx) [insertion_idx node] - [(inc insertion_idx) + [(++ insertion_idx) [(with_bit_position (to_bit_position idx) bitmap) (array.write! insertion_idx (#.Left sub_node) base)]]) ))) [0 [clean_bitmap - (array.empty (dec h_size))]] + (array.empty (-- h_size))]] (list.indices (array.size h_array))))) ... When #Base nodes grow too large, they're promoted to #Hierarchy to @@ -263,7 +263,7 @@ (product.right (list\fold (function (_ hierarchy_idx (^@ default [base_idx h_array])) (if (with_bit_position? (to_bit_position hierarchy_idx) bitmap) - [(inc base_idx) + [(++ base_idx) (case (array.read! base_idx base) (#.Some (#.Left sub_node)) (array.write! hierarchy_idx sub_node h_array) @@ -304,7 +304,7 @@ [_size sub_node] _ - [(inc _size) empty_node])] + [(++ _size) empty_node])] (#Hierarchy _size' (array\revised idx (node\has (level_up level) hash key val key_hash sub_node) hierarchy))) @@ -357,7 +357,7 @@ (if (n.>= ..promotion_threshold base_count) ... If so, promote it to a #Hierarchy node, and add the new ... KV-pair as a singleton node to it. - (#Hierarchy (inc base_count) + (#Hierarchy (++ base_count) (|> base (promotion node\has key_hash level bitmap) (array.write! (level_index level hash) @@ -415,7 +415,7 @@ ... If so, perform it. (#Base (demotion idx [h_size h_array])) ... Otherwise, just clear the space. - (#Hierarchy (dec h_size) (array\lacks' idx h_array))) + (#Hierarchy (-- h_size) (array\lacks' idx h_array))) ... But if the sub_removal yielded a non_empty node, then ... just update the hiearchy branch. (#Hierarchy h_size (array\revised idx sub_node' h_array))))))) @@ -562,7 +562,7 @@ (def: .public key_hash (All [k v] (-> (Dictionary k v) (Hash k))) - (get@ #..hash)) + (value@ #..hash)) (def: .public (empty key_hash) {#.doc (example "An empty dictionary.")} @@ -737,4 +737,4 @@ (All [k] (Functor (Dictionary k))) (def: (map f fa) - (update@ #root (\ ..functor' map f) fa))) + (revised@ #root (\ ..functor' map f) fa))) diff --git a/stdlib/source/library/lux/data/collection/dictionary/ordered.lux b/stdlib/source/library/lux/data/collection/dictionary/ordered.lux index 84e883b1d..567c1f457 100644 --- a/stdlib/source/library/lux/data/collection/dictionary/ordered.lux +++ b/stdlib/source/library/lux/data/collection/dictionary/ordered.lux @@ -60,60 +60,60 @@ ... TODO: Must improve it as soon as bug is fixed. (def: .public (value key dict) (All [k v] (-> k (Dictionary k v) (Maybe v))) - (let [... (^open "_\.") (get@ #&order dict) + (let [... (^open "_\.") (value@ #&order dict) ] - (loop [node (get@ #root dict)] + (loop [node (value@ #root dict)] (case node #.None #.None (#.Some node) - (let [node_key (get@ #key node)] + (let [node_key (value@ #key node)] (cond (\ dict = node_key key) ... (_\= node_key key) - (#.Some (get@ #value node)) + (#.Some (value@ #value node)) (\ dict < node_key key) ... (_\< node_key key) - (recur (get@ #left node)) + (recur (value@ #left node)) - ... (_\> (get@ #key node) key) - (recur (get@ #right node)))) + ... (_\> (value@ #key node) key) + (recur (value@ #right node)))) )))) ... TODO: Doing inneficient access of Order functions due to compiler bug. ... TODO: Must improve it as soon as bug is fixed. (def: .public (key? dict key) (All [k v] (-> (Dictionary k v) k Bit)) - (let [... (^open "_\.") (get@ #&order dict) + (let [... (^open "_\.") (value@ #&order dict) ] - (loop [node (get@ #root dict)] + (loop [node (value@ #root dict)] (case node #.None #0 (#.Some node) - (let [node_key (get@ #key node)] + (let [node_key (value@ #key node)] (or (\ dict = node_key key) ... (_\= node_key key) (if (\ dict < node_key key) ... (_\< node_key key) - (recur (get@ #left node)) - (recur (get@ #right node))))))))) + (recur (value@ #left node)) + (recur (value@ #right node))))))))) (template [<name> <side>] [(def: .public (<name> dict) {#.doc (example (~~ (template.text ["Yields value under the " <name> "imum key."])))} (All [k v] (-> (Dictionary k v) (Maybe v))) - (case (get@ #root dict) + (case (value@ #root dict) #.None #.None (#.Some node) (loop [node node] - (case (get@ <side> node) + (case (value@ <side> node) #.None - (#.Some (get@ #value node)) + (#.Some (value@ #value node)) (#.Some side) (recur side)))))] @@ -124,14 +124,14 @@ (def: .public (size dict) (All [k v] (-> (Dictionary k v) Nat)) - (loop [node (get@ #root dict)] + (loop [node (value@ #root dict)] (case node #.None 0 (#.Some node) - (inc (n.+ (recur (get@ #left node)) - (recur (get@ #right node))))))) + (++ (n.+ (recur (value@ #left node)) + (recur (value@ #right node))))))) (def: .public empty? (All [k v] (-> (Dictionary k v) Bit)) @@ -140,9 +140,9 @@ (template [<name> <other_color> <self_color> <no_change>] [(def: (<name> self) (All [k v] (-> (Node k v) (Node k v))) - (case (get@ #color self) + (case (value@ #color self) <other_color> - (set@ #color <self_color> self) + (with@ #color <self_color> self) <self_color> <no_change> @@ -154,46 +154,46 @@ (def: (with_left addition center) (All [k v] (-> (Node k v) (Node k v) (Node k v))) - (case (get@ #color center) + (case (value@ #color center) #Red - (red (get@ #key center) - (get@ #value center) + (red (value@ #key center) + (value@ #value center) (#.Some addition) - (get@ #right center)) + (value@ #right center)) #Black (with_expansions - [<default_behavior> (as_is (black (get@ #key center) - (get@ #value center) + [<default_behavior> (as_is (black (value@ #key center) + (value@ #value center) (#.Some addition) - (get@ #right center)))] - (case (get@ #color addition) + (value@ #right center)))] + (case (value@ #color addition) #Red - (case (get@ #left addition) + (case (value@ #left addition) (^multi (#.Some left) - {(get@ #color left) #Red}) - (red (get@ #key addition) - (get@ #value addition) + {(value@ #color left) #Red}) + (red (value@ #key addition) + (value@ #value addition) (#.Some (blackened left)) - (#.Some (black (get@ #key center) - (get@ #value center) - (get@ #right addition) - (get@ #right center)))) + (#.Some (black (value@ #key center) + (value@ #value center) + (value@ #right addition) + (value@ #right center)))) _ - (case (get@ #right addition) + (case (value@ #right addition) (^multi (#.Some right) - {(get@ #color right) #Red}) - (red (get@ #key right) - (get@ #value right) - (#.Some (black (get@ #key addition) - (get@ #value addition) - (get@ #left addition) - (get@ #left right))) - (#.Some (black (get@ #key center) - (get@ #value center) - (get@ #right right) - (get@ #right center)))) + {(value@ #color right) #Red}) + (red (value@ #key right) + (value@ #value right) + (#.Some (black (value@ #key addition) + (value@ #value addition) + (value@ #left addition) + (value@ #left right))) + (#.Some (black (value@ #key center) + (value@ #value center) + (value@ #right right) + (value@ #right center)))) _ <default_behavior>)) @@ -203,46 +203,46 @@ (def: (with_right addition center) (All [k v] (-> (Node k v) (Node k v) (Node k v))) - (case (get@ #color center) + (case (value@ #color center) #Red - (red (get@ #key center) - (get@ #value center) - (get@ #left center) + (red (value@ #key center) + (value@ #value center) + (value@ #left center) (#.Some addition)) #Black (with_expansions - [<default_behavior> (as_is (black (get@ #key center) - (get@ #value center) - (get@ #left center) + [<default_behavior> (as_is (black (value@ #key center) + (value@ #value center) + (value@ #left center) (#.Some addition)))] - (case (get@ #color addition) + (case (value@ #color addition) #Red - (case (get@ #right addition) + (case (value@ #right addition) (^multi (#.Some right) - {(get@ #color right) #Red}) - (red (get@ #key addition) - (get@ #value addition) - (#.Some (black (get@ #key center) - (get@ #value center) - (get@ #left center) - (get@ #left addition))) + {(value@ #color right) #Red}) + (red (value@ #key addition) + (value@ #value addition) + (#.Some (black (value@ #key center) + (value@ #value center) + (value@ #left center) + (value@ #left addition))) (#.Some (blackened right))) _ - (case (get@ #left addition) + (case (value@ #left addition) (^multi (#.Some left) - {(get@ #color left) #Red}) - (red (get@ #key left) - (get@ #value left) - (#.Some (black (get@ #key center) - (get@ #value center) - (get@ #left center) - (get@ #left left))) - (#.Some (black (get@ #key addition) - (get@ #value addition) - (get@ #right left) - (get@ #right addition)))) + {(value@ #color left) #Red}) + (red (value@ #key left) + (value@ #value left) + (#.Some (black (value@ #key center) + (value@ #value center) + (value@ #left center) + (value@ #left left))) + (#.Some (black (value@ #key addition) + (value@ #value addition) + (value@ #right left) + (value@ #right addition)))) _ <default_behavior>)) @@ -252,17 +252,17 @@ (def: .public (has key value dict) (All [k v] (-> k v (Dictionary k v) (Dictionary k v))) - (let [(^open "_\.") (get@ #&order dict) - root' (loop [?root (get@ #root dict)] + (let [(^open "_\.") (value@ #&order dict) + root' (loop [?root (value@ #root dict)] (case ?root #.None (#.Some (red key value #.None #.None)) (#.Some root) - (let [reference (get@ #key root)] + (let [reference (value@ #key root)] (`` (cond (~~ (template [<comp> <tag> <add>] [(<comp> reference key) - (let [side_root (get@ <tag> root) + (let [side_root (value@ <tag> root) outcome (recur side_root)] (if (same? side_root outcome) ?root @@ -270,39 +270,39 @@ root))))] [_\< #left ..with_left] - [(order.> (get@ #&order dict)) #right ..with_right] + [(order.> (value@ #&order dict)) #right ..with_right] )) ... (_\= reference key) - (#.Some (set@ #value value root)) + (#.Some (with@ #value value root)) ))) ))] - (set@ #root root' dict))) + (with@ #root root' dict))) (def: (left_balanced key value ?left ?right) (All [k v] (-> k v (Maybe (Node k v)) (Maybe (Node k v)) (Node k v))) (case ?left (^multi (#.Some left) - {(get@ #color left) #Red} - {(get@ #left left) (#.Some left>>left)} - {(get@ #color left>>left) #Red}) - (red (get@ #key left) - (get@ #value left) + {(value@ #color left) #Red} + {(value@ #left left) (#.Some left>>left)} + {(value@ #color left>>left) #Red}) + (red (value@ #key left) + (value@ #value left) (#.Some (blackened left>>left)) - (#.Some (black key value (get@ #right left) ?right))) + (#.Some (black key value (value@ #right left) ?right))) (^multi (#.Some left) - {(get@ #color left) #Red} - {(get@ #right left) (#.Some left>>right)} - {(get@ #color left>>right) #Red}) - (red (get@ #key left>>right) - (get@ #value left>>right) - (#.Some (black (get@ #key left) - (get@ #value left) - (get@ #left left) - (get@ #left left>>right))) + {(value@ #color left) #Red} + {(value@ #right left) (#.Some left>>right)} + {(value@ #color left>>right) #Red}) + (red (value@ #key left>>right) + (value@ #value left>>right) + (#.Some (black (value@ #key left) + (value@ #value left) + (value@ #left left) + (value@ #left left>>right))) (#.Some (black key value - (get@ #right left>>right) + (value@ #right left>>right) ?right))) _ @@ -312,25 +312,25 @@ (All [k v] (-> k v (Maybe (Node k v)) (Maybe (Node k v)) (Node k v))) (case ?right (^multi (#.Some right) - {(get@ #color right) #Red} - {(get@ #right right) (#.Some right>>right)} - {(get@ #color right>>right) #Red}) - (red (get@ #key right) - (get@ #value right) - (#.Some (black key value ?left (get@ #left right))) + {(value@ #color right) #Red} + {(value@ #right right) (#.Some right>>right)} + {(value@ #color right>>right) #Red}) + (red (value@ #key right) + (value@ #value right) + (#.Some (black key value ?left (value@ #left right))) (#.Some (blackened right>>right))) (^multi (#.Some right) - {(get@ #color right) #Red} - {(get@ #left right) (#.Some right>>left)} - {(get@ #color right>>left) #Red}) - (red (get@ #key right>>left) - (get@ #value right>>left) - (#.Some (black key value ?left (get@ #left right>>left))) - (#.Some (black (get@ #key right) - (get@ #value right) - (get@ #right right>>left) - (get@ #right right)))) + {(value@ #color right) #Red} + {(value@ #left right) (#.Some right>>left)} + {(value@ #color right>>left) #Red}) + (red (value@ #key right>>left) + (value@ #value right>>left) + (#.Some (black key value ?left (value@ #left right>>left))) + (#.Some (black (value@ #key right) + (value@ #value right) + (value@ #right right>>left) + (value@ #right right)))) _ (black key value ?left ?right))) @@ -339,26 +339,26 @@ (All [k v] (-> k v (Maybe (Node k v)) (Maybe (Node k v)) (Node k v))) (case ?left (^multi (#.Some left) - {(get@ #color left) #Red}) + {(value@ #color left) #Red}) (red key value (#.Some (blackened left)) ?right) _ (case ?right (^multi (#.Some right) - {(get@ #color right) #Black}) + {(value@ #color right) #Black}) (right_balanced key value ?left (#.Some (reddened right))) (^multi (#.Some right) - {(get@ #color right) #Red} - {(get@ #left right) (#.Some right>>left)} - {(get@ #color right>>left) #Black}) - (red (get@ #key right>>left) - (get@ #value right>>left) - (#.Some (black key value ?left (get@ #left right>>left))) - (#.Some (right_balanced (get@ #key right) - (get@ #value right) - (get@ #right right>>left) - (\ maybe.functor map reddened (get@ #right right))))) + {(value@ #color right) #Red} + {(value@ #left right) (#.Some right>>left)} + {(value@ #color right>>left) #Black}) + (red (value@ #key right>>left) + (value@ #value right>>left) + (#.Some (black key value ?left (value@ #left right>>left))) + (#.Some (right_balanced (value@ #key right) + (value@ #value right) + (value@ #right right>>left) + (\ maybe.functor map reddened (value@ #right right))))) _ (panic! error_message)) @@ -368,26 +368,26 @@ (All [k v] (-> k v (Maybe (Node k v)) (Maybe (Node k v)) (Node k v))) (case ?right (^multi (#.Some right) - {(get@ #color right) #Red}) + {(value@ #color right) #Red}) (red key value ?left (#.Some (blackened right))) _ (case ?left (^multi (#.Some left) - {(get@ #color left) #Black}) + {(value@ #color left) #Black}) (left_balanced key value (#.Some (reddened left)) ?right) (^multi (#.Some left) - {(get@ #color left) #Red} - {(get@ #right left) (#.Some left>>right)} - {(get@ #color left>>right) #Black}) - (red (get@ #key left>>right) - (get@ #value left>>right) - (#.Some (left_balanced (get@ #key left) - (get@ #value left) - (\ maybe.functor map reddened (get@ #left left)) - (get@ #left left>>right))) - (#.Some (black key value (get@ #right left>>right) ?right))) + {(value@ #color left) #Red} + {(value@ #right left) (#.Some left>>right)} + {(value@ #color left>>right) #Black}) + (red (value@ #key left>>right) + (value@ #value left>>right) + (#.Some (left_balanced (value@ #key left) + (value@ #value left) + (\ maybe.functor map reddened (value@ #left left)) + (value@ #left left>>right))) + (#.Some (black key value (value@ #right left>>right) ?right))) _ (panic! error_message) @@ -403,70 +403,70 @@ ?left [(#.Some left) (#.Some right)] - (case [(get@ #color left) (get@ #color right)] + (case [(value@ #color left) (value@ #color right)] [#Red #Red] (do maybe.monad - [fused (prepended (get@ #right left) (get@ #right right))] - (case (get@ #color fused) + [fused (prepended (value@ #right left) (value@ #right right))] + (case (value@ #color fused) #Red - (in (red (get@ #key fused) - (get@ #value fused) - (#.Some (red (get@ #key left) - (get@ #value left) - (get@ #left left) - (get@ #left fused))) - (#.Some (red (get@ #key right) - (get@ #value right) - (get@ #right fused) - (get@ #right right))))) + (in (red (value@ #key fused) + (value@ #value fused) + (#.Some (red (value@ #key left) + (value@ #value left) + (value@ #left left) + (value@ #left fused))) + (#.Some (red (value@ #key right) + (value@ #value right) + (value@ #right fused) + (value@ #right right))))) #Black - (in (red (get@ #key left) - (get@ #value left) - (get@ #left left) - (#.Some (red (get@ #key right) - (get@ #value right) + (in (red (value@ #key left) + (value@ #value left) + (value@ #left left) + (#.Some (red (value@ #key right) + (value@ #value right) (#.Some fused) - (get@ #right right))))))) + (value@ #right right))))))) [#Red #Black] - (#.Some (red (get@ #key left) - (get@ #value left) - (get@ #left left) - (prepended (get@ #right left) + (#.Some (red (value@ #key left) + (value@ #value left) + (value@ #left left) + (prepended (value@ #right left) ?right))) [#Black #Red] - (#.Some (red (get@ #key right) - (get@ #value right) + (#.Some (red (value@ #key right) + (value@ #value right) (prepended ?left - (get@ #left right)) - (get@ #right right))) + (value@ #left right)) + (value@ #right right))) [#Black #Black] (do maybe.monad - [fused (prepended (get@ #right left) (get@ #left right))] - (case (get@ #color fused) + [fused (prepended (value@ #right left) (value@ #left right))] + (case (value@ #color fused) #Red - (in (red (get@ #key fused) - (get@ #value fused) - (#.Some (black (get@ #key left) - (get@ #value left) - (get@ #left left) - (get@ #left fused))) - (#.Some (black (get@ #key right) - (get@ #value right) - (get@ #right fused) - (get@ #right right))))) + (in (red (value@ #key fused) + (value@ #value fused) + (#.Some (black (value@ #key left) + (value@ #value left) + (value@ #left left) + (value@ #left fused))) + (#.Some (black (value@ #key right) + (value@ #value right) + (value@ #right fused) + (value@ #right right))))) #Black - (in (without_left (get@ #key left) - (get@ #value left) - (get@ #left left) - (#.Some (black (get@ #key right) - (get@ #value right) + (in (without_left (value@ #key left) + (value@ #value left) + (value@ #left left) + (#.Some (black (value@ #key right) + (value@ #value right) (#.Some fused) - (get@ #right right))))) + (value@ #right right))))) )) ) @@ -475,45 +475,45 @@ (def: .public (lacks key dict) (All [k v] (-> k (Dictionary k v) (Dictionary k v))) - (let [(^open "_\.") (get@ #&order dict) - [?root found?] (loop [?root (get@ #root dict)] + (let [(^open "_\.") (value@ #&order dict) + [?root found?] (loop [?root (value@ #root dict)] (case ?root #.None [#.None #0] (#.Some root) - (let [root_key (get@ #key root) - root_val (get@ #value root)] + (let [root_key (value@ #key root) + root_val (value@ #value root)] (if (_\= root_key key) - [(prepended (get@ #left root) - (get@ #right root)) + [(prepended (value@ #left root) + (value@ #right root)) #1] (let [go_left? (_\< root_key key)] (case (recur (if go_left? - (get@ #left root) - (get@ #right root))) + (value@ #left root) + (value@ #right root))) [#.None #0] [#.None #0] [side_outcome _] (if go_left? - (case (get@ #left root) + (case (value@ #left root) (^multi (#.Some left) - {(get@ #color left) #Black}) - [(#.Some (without_left root_key root_val side_outcome (get@ #right root))) + {(value@ #color left) #Black}) + [(#.Some (without_left root_key root_val side_outcome (value@ #right root))) #0] _ - [(#.Some (red root_key root_val side_outcome (get@ #right root))) + [(#.Some (red root_key root_val side_outcome (value@ #right root))) #0]) - (case (get@ #right root) + (case (value@ #right root) (^multi (#.Some right) - {(get@ #color right) #Black}) - [(#.Some (without_right root_key root_val (get@ #left root) side_outcome)) + {(value@ #color right) #Black}) + [(#.Some (without_right root_key root_val (value@ #left root) side_outcome)) #0] _ - [(#.Some (red root_key root_val (get@ #left root) side_outcome)) + [(#.Some (red root_key root_val (value@ #left root) side_outcome)) #0]) ))) )) @@ -521,11 +521,11 @@ (case ?root #.None (if found? - (set@ #root ?root dict) + (with@ #root ?root dict) dict) (#.Some root) - (set@ #root (#.Some (blackened root)) dict) + (with@ #root (#.Some (blackened root)) dict) ))) (def: .public (revised key transform dict) @@ -547,27 +547,27 @@ (template [<name> <type> <output>] [(def: .public (<name> dict) (All [k v] (-> (Dictionary k v) (List <type>))) - (loop [node (get@ #root dict)] + (loop [node (value@ #root dict)] (case node #.None (list) (#.Some node') ($_ list\compose - (recur (get@ #left node')) + (recur (value@ #left node')) (list <output>) - (recur (get@ #right node'))))))] + (recur (value@ #right node'))))))] - [entries [k v] [(get@ #key node') (get@ #value node')]] - [keys k (get@ #key node')] - [values v (get@ #value node')] + [entries [k v] [(value@ #key node') (value@ #value node')]] + [keys k (value@ #key node')] + [values v (value@ #value node')] ) (implementation: .public (equivalence (^open ",\.")) (All [k v] (-> (Equivalence v) (Equivalence (Dictionary k v)))) (def: (= reference sample) - (let [(^open "/\.") (get@ #&order reference)] + (let [(^open "/\.") (value@ #&order reference)] (loop [entriesR (entries reference) entriesS (entries sample)] (case [entriesR entriesS] diff --git a/stdlib/source/library/lux/data/collection/list.lux b/stdlib/source/library/lux/data/collection/list.lux index 8cba7efb2..cb52d478d 100644 --- a/stdlib/source/library/lux/data/collection/list.lux +++ b/stdlib/source/library/lux/data/collection/list.lux @@ -34,14 +34,14 @@ (#.Item x xs') (fold f (f x init) xs')))) -(def: .public (folds f init inputs) +(def: .public (aggregates f init inputs) (All [a b] (-> (-> a b b) b (List a) (List b))) (case inputs #.End (list init) (#.Item [head tail]) - (#.Item [init (folds f (f head init) tail)]))) + (#.Item [init (aggregates f (f head init) tail)]))) (def: .public (reversed xs) (All [a] @@ -100,8 +100,8 @@ <then>) <else>))] - [first (#.Item x (first (dec n) xs')) #.End] - [after (after (dec n) xs') xs] + [first (#.Item x (first (-- n) xs')) #.End] + [after (after (-- n) xs') xs] ) (template [<name> <then> <else>] @@ -130,7 +130,7 @@ [#.End #.End] (#.Item x xs') - (let [[tail rest] (split_at (dec n) xs')] + (let [[tail rest] (split_at (-- n) xs')] [(#.Item x tail) rest])) [#.End xs])) @@ -170,7 +170,7 @@ (-> Nat a (List a))) (case n 0 #.End - _ (#.Item x (repeated (dec n) x)))) + _ (#.Item x (repeated (-- n) x)))) (def: (iterations' f x) (All [a] @@ -263,21 +263,16 @@ (fold (function (_ _ acc) (n.+ 1 acc)) 0 list)) (template [<name> <init> <op>] - [(def: .public (<name> predicate xs) + [(def: .public (<name> predicate items) (All [a] (-> (Predicate a) (List a) Bit)) - (loop [xs xs] - (case xs - #.End - <init> - - (#.Item x xs') - (case (predicate x) - <init> - (recur xs') + (case items + #.End + <init> - output - output))))] + (#.Item head tail) + (<op> (predicate head) + (<name> predicate tail))))] [every? #1 and] [any? #0 or] @@ -292,9 +287,9 @@ #.None (#.Item x xs') - (if (n.= 0 i) - (#.Some x) - (item (dec i) xs')))) + (case i + 0 (#.Some x) + _ (item (-- i) xs')))) (implementation: .public (equivalence Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (List a)))) @@ -428,9 +423,9 @@ (def: .public (indices size) {#.doc "Produces all the valid indices for a given size."} (All [a] (-> Nat (List Nat))) - (if (n.= 0 size) - (list) - (|> size dec (enum.range n.enum 0)))) + (case size + 0 (list) + _ (|> size -- (enum.range n.enum 0)))) (def: (identifier$ name) (-> Text Code) @@ -454,9 +449,9 @@ _ (undefined)) output' ("lux text concat" digit output) input' (n./ 10 input)] - (if (n.= 0 input') - output' - (recur input' output'))))) + (case input' + 0 output' + _ (recur input' output'))))) (macro: .public (zipped tokens state) {#.doc (.example "Create list zippers with the specified number of input lists." @@ -475,7 +470,7 @@ type_vars)) (List [(~+ type_vars)])))) vars+lists (|> indices - (map inc) + (map ++) (map (function (_ idx) (let [base (nat\encode idx)] [(identifier$ base) @@ -523,7 +518,7 @@ type_vars)) (List (~ g!return_type))))) vars+lists (|> indices - (map inc) + (map ++) (map (function (_ idx) (let [base (nat\encode idx)] [(identifier$ base) @@ -583,7 +578,7 @@ (#.Some (#.Item x tail))) )) -(def: .public joined +(def: .public together {#.doc (.example "The sequential combination of all the lists.")} (All [a] (-> (List (List a)) (List a))) (\ ..monad join)) @@ -593,7 +588,8 @@ (All [M] (-> (Monad M) (Monad (All [a] (M (List a)))))) (def: &functor - (functor.composite (get@ #monad.&functor monad) ..functor)) + (functor.composite (value@ #monad.&functor monad) + ..functor)) (def: in (|>> (\ ..monad in) (\ monad in))) @@ -604,9 +600,9 @@ ... TODO: Remove this version ASAP and use one below. lla (for {@.old (: ((:parameter 0) (List (List (:parameter 1)))) - (monad.seq ! lMla))} - (monad.seq ! lMla))] - (in (..joined lla))))) + (monad.all ! lMla))} + (monad.all ! lMla))] + (in (..together lla))))) (def: .public (lifted monad) {#.doc (.example "Wraps a monadic value with List machinery.")} @@ -623,7 +619,7 @@ #.End (#.Item x xs') - (#.Item [idx x] (recur (inc idx) xs'))))) + (#.Item [idx x] (recur (++ idx) xs'))))) (macro: .public (when tokens state) {#.doc (.example "Can be used as a guard in (co)monadic be/do expressions." diff --git a/stdlib/source/library/lux/data/collection/queue.lux b/stdlib/source/library/lux/data/collection/queue.lux index 3e017d382..a54543eae 100644 --- a/stdlib/source/library/lux/data/collection/queue.lux +++ b/stdlib/source/library/lux/data/collection/queue.lux @@ -34,7 +34,7 @@ (def: .public front {#.doc (example "Yields the first value in the queue, if any.")} (All [a] (-> (Queue a) (Maybe a))) - (|>> (get@ #front) list.head)) + (|>> (value@ #front) list.head)) (def: .public (size queue) (All [a] (-> (Queue a) Nat)) @@ -44,7 +44,7 @@ (def: .public empty? (All [a] (-> (Queue a) Bit)) - (|>> (get@ #front) list.empty?)) + (|>> (value@ #front) list.empty?)) (def: .public (member? equivalence queue member) (All [a] (-> (Equivalence a) (Queue a) a Bit)) @@ -54,7 +54,7 @@ (def: .public (next queue) (All [a] (-> (Queue a) (Queue a))) - (case (get@ #front queue) + (case (value@ #front queue) ... Empty... (^ (.list)) queue @@ -62,22 +62,22 @@ ... Front has dried up... (^ (.list _)) (|> queue - (set@ #front (list.reversed (get@ #rear queue))) - (set@ #rear (.list))) + (with@ #front (list.reversed (value@ #rear queue))) + (with@ #rear (.list))) ... Consume front! (^ (.list& _ front')) (|> queue - (set@ #front front')))) + (with@ #front front')))) (def: .public (end val queue) (All [a] (-> a (Queue a) (Queue a))) - (case (get@ #front queue) + (case (value@ #front queue) #.End - (set@ #front (.list val) queue) + (with@ #front (.list val) queue) _ - (update@ #rear (|>> (#.Item val)) queue))) + (revised@ #rear (|>> (#.Item val)) queue))) (implementation: .public (equivalence super) (All [a] (-> (Equivalence a) (Equivalence (Queue a)))) @@ -91,5 +91,5 @@ (Functor Queue) (def: (map f fa) - {#front (|> fa (get@ #front) (list\map f)) - #rear (|> fa (get@ #rear) (list\map f))})) + {#front (|> fa (value@ #front) (list\map f)) + #rear (|> fa (value@ #rear) (list\map f))})) diff --git a/stdlib/source/library/lux/data/collection/row.lux b/stdlib/source/library/lux/data/collection/row.lux index 6a4b88587..e77ef1bdf 100644 --- a/stdlib/source/library/lux/data/collection/row.lux +++ b/stdlib/source/library/lux/data/collection/row.lux @@ -17,8 +17,8 @@ ["." maybe] ["." try (#+ Try)] ["." exception (#+ exception:)] - ["p" parser - ["s" code (#+ Parser)]]] + ["<>" parser + ["<.>" code (#+ Parser)]]] [data ["." product] [collection @@ -29,8 +29,8 @@ ["." code]] [math [number - ["." i64] - ["n" nat]]]]]) + ["n" nat] + ["." i64]]]]]) (type: (Node a) (#Base (Array a)) @@ -66,7 +66,7 @@ (def: branch_idx_mask Nat - (dec full_node_size)) + (-- full_node_size)) (def: branch_idx (-> Index Index) @@ -80,7 +80,7 @@ (-> Nat Nat) (if (n.< full_node_size row_size) 0 - (|> (dec row_size) + (|> (-- row_size) (i64.right_shifted branching_exponent) (i64.left_shifted branching_exponent)))) @@ -99,7 +99,7 @@ (def: (with_tail size level tail parent) (All [a] (-> Nat Level (Base a) (Hierarchy a) (Hierarchy a))) - (let [sub_idx (branch_idx (i64.right_shifted level (dec size))) + (let [sub_idx (branch_idx (i64.right_shifted level (-- size))) ... If we're currently on a bottom node sub_node (if (n.= branching_exponent level) ... Just add the tail to it @@ -122,7 +122,7 @@ (def: (expanded_tail val tail) (All [a] (-> a (Base a) (Base a))) (let [tail_size (array.size tail)] - (|> (array.empty (inc tail_size)) + (|> (array.empty (++ tail_size)) (array.copy! tail_size 0 tail 0) (array.write! tail_size val)))) @@ -198,45 +198,45 @@ (def: .public (size row) (All [a] (-> (Row a) Nat)) - (get@ #size row)) + (value@ #size row)) -(def: .public (add val row) +(def: .public (suffix val row) (All [a] (-> a (Row a) (Row a))) ... Check if there is room in the tail. - (let [row_size (get@ #size row)] + (let [row_size (value@ #size row)] (if (|> row_size (n.- (tail_off row_size)) (n.< full_node_size)) ... If so, append to it. (|> row - (update@ #size inc) - (update@ #tail (..expanded_tail val))) + (revised@ #size ++) + (revised@ #tail (..expanded_tail val))) ... Otherwise, push tail into the tree ... -------------------------------------------------------- ... Will the root experience an overflow with this addition? - (|> (if (n.> (i64.left_shifted (get@ #level row) 1) + (|> (if (n.> (i64.left_shifted (value@ #level row) 1) (i64.right_shifted branching_exponent row_size)) ... If so, a brand-new root must be established, that is ... 1-level taller. (|> row - (set@ #root (|> (for {@.old - (: (Hierarchy (:parameter 0)) - (empty_hierarchy []))} - (empty_hierarchy [])) - (array.write! 0 (#Hierarchy (get@ #root row))) - (array.write! 1 (..path (get@ #level row) (get@ #tail row))))) - (update@ #level level_up)) + (with@ #root (|> (for {@.old + (: (Hierarchy (:parameter 0)) + (empty_hierarchy []))} + (empty_hierarchy [])) + (array.write! 0 (#Hierarchy (value@ #root row))) + (array.write! 1 (..path (value@ #level row) (value@ #tail row))))) + (revised@ #level level_up)) ... Otherwise, just push the current tail onto the root. (|> row - (update@ #root (..with_tail row_size (get@ #level row) (get@ #tail row))))) + (revised@ #root (..with_tail row_size (value@ #level row) (value@ #tail row))))) ... Finally, update the size of the row and grow a new ... tail with the new element as it's sole member. - (update@ #size inc) - (set@ #tail (..tail val))) + (revised@ #size ++) + (with@ #tail (..tail val))) ))) (exception: incorrect_row_structure) (exception: .public [a] (index_out_of_bounds {row (Row a)} {index Nat}) - (exception.report ["Size" (\ n.decimal encode (get@ #size row))] + (exception.report ["Size" (\ n.decimal encode (value@ #size row))] ["Index" (\ n.decimal encode index)])) (exception: base_was_not_found) @@ -244,15 +244,15 @@ (def: .public (within_bounds? row idx) {#.doc (example "Determines whether the index is within the bounds of the row.")} (All [a] (-> (Row a) Nat Bit)) - (n.< (get@ #size row) idx)) + (n.< (value@ #size row) idx)) (def: (base_for idx row) (All [a] (-> Index (Row a) (Try (Base a)))) (if (within_bounds? row idx) - (if (n.>= (tail_off (get@ #size row)) idx) - (#try.Success (get@ #tail row)) - (loop [level (get@ #level row) - hierarchy (get@ #root row)] + (if (n.>= (tail_off (value@ #size row)) idx) + (#try.Success (value@ #tail row)) + (loop [level (value@ #level row) + hierarchy (value@ #root row)] (case [(n.> branching_exponent level) (array.read! (branch_idx (i64.right_shifted level idx)) hierarchy)] [#1 (#.Some (#Hierarchy sub))] @@ -281,16 +281,16 @@ (def: .public (has idx val row) (All [a] (-> Nat a (Row a) (Try (Row a)))) - (let [row_size (get@ #size row)] + (let [row_size (value@ #size row)] (if (within_bounds? row idx) (#try.Success (if (n.>= (tail_off row_size) idx) - (update@ #tail (for {@.old - (: (-> (Base (:parameter 0)) (Base (:parameter 0))) - (|>> array.clone (array.write! (branch_idx idx) val)))} - (|>> array.clone (array.write! (branch_idx idx) val))) - row) - (update@ #root (has' (get@ #level row) idx val) - row))) + (revised@ #tail (for {@.old + (: (-> (Base (:parameter 0)) (Base (:parameter 0))) + (|>> array.clone (array.write! (branch_idx idx) val)))} + (|>> array.clone (array.write! (branch_idx idx) val))) + row) + (revised@ #root (has' (value@ #level row) idx val) + row))) (exception.except ..index_out_of_bounds [row idx])))) (def: .public (revised idx f row) @@ -299,9 +299,9 @@ [val (..item idx row)] (..has idx (f val) row))) -(def: .public (pop row) +(def: .public (prefix row) (All [a] (-> (Row a) (Row a))) - (case (get@ #size row) + (case (value@ #size row) 0 empty @@ -310,19 +310,19 @@ row_size (if (|> row_size (n.- (tail_off row_size)) (n.> 1)) - (let [old_tail (get@ #tail row) - new_tail_size (dec (array.size old_tail))] + (let [old_tail (value@ #tail row) + new_tail_size (-- (array.size old_tail))] (|> row - (update@ #size dec) - (set@ #tail (|> (array.empty new_tail_size) - (array.copy! new_tail_size 0 old_tail 0))))) + (revised@ #size --) + (with@ #tail (|> (array.empty new_tail_size) + (array.copy! new_tail_size 0 old_tail 0))))) (maybe.trusted (do maybe.monad [new_tail (base_for (n.- 2 row_size) row) - .let [[level' root'] (let [init_level (get@ #level row)] + .let [[level' root'] (let [init_level (value@ #level row)] (loop [level init_level root (maybe.else (empty_hierarchy []) - (without_tail row_size init_level (get@ #root row)))] + (without_tail row_size init_level (value@ #root row)))] (if (n.> branching_exponent level) (case [(array.read! 1 root) (array.read! 0 root)] [#.None (#.Some (#Hierarchy sub_node))] @@ -335,20 +335,20 @@ [level root]) [level root])))]] (in (|> row - (update@ #size dec) - (set@ #level level') - (set@ #root root') - (set@ #tail new_tail)))))) + (revised@ #size --) + (with@ #level level') + (with@ #root root') + (with@ #tail new_tail)))))) )) (def: .public (list row) (All [a] (-> (Row a) (List a))) - (list\compose (list' (#Hierarchy (get@ #root row))) - (list' (#Base (get@ #tail row))))) + (list\compose (list' (#Hierarchy (value@ #root row))) + (list' (#Base (value@ #tail row))))) (def: .public of_list (All [a] (-> (List a) (Row a))) - (list\fold ..add ..empty)) + (list\fold ..suffix ..empty)) (def: .public (member? a/Equivalence row val) (All [a] (-> (Equivalence a) (Row a) a Bit)) @@ -356,9 +356,9 @@ (def: .public empty? (All [a] (-> (Row a) Bit)) - (|>> (get@ #size) (n.= 0))) + (|>> (value@ #size) (n.= 0))) -(syntax: .public (row [elems (p.some s.any)]) +(syntax: .public (row [elems (<>.some <code>.any)]) {#.doc (example "Row literals." (row 12 34 56 78 90))} (in (.list (` (..of_list (.list (~+ elems))))))) @@ -381,12 +381,12 @@ (All [a] (-> (Equivalence a) (Equivalence (Row a)))) (def: (= v1 v2) - (and (n.= (get@ #size v1) (get@ #size v2)) + (and (n.= (value@ #size v1) (value@ #size v2)) (let [(^open "node\.") (node_equivalence Equivalence<a>)] - (and (node\= (#Base (get@ #tail v1)) - (#Base (get@ #tail v2))) - (node\= (#Hierarchy (get@ #root v1)) - (#Hierarchy (get@ #root v2)))))))) + (and (node\= (#Base (value@ #tail v1)) + (#Base (value@ #tail v2))) + (node\= (#Hierarchy (value@ #root v1)) + (#Hierarchy (value@ #root v2)))))))) (implementation: node_fold (Fold Node) @@ -409,8 +409,8 @@ (fold f (fold f init - (#Hierarchy (get@ #root xs))) - (#Base (get@ #tail xs)))))) + (#Hierarchy (value@ #root xs))) + (#Base (value@ #tail xs)))))) (implementation: .public monoid (All [a] (Monoid (Row a))) @@ -418,7 +418,7 @@ (def: identity ..empty) (def: (compose xs ys) - (list\fold add xs (..list ys)))) + (list\fold suffix xs (..list ys)))) (implementation: node_functor (Functor Node) @@ -435,10 +435,10 @@ (Functor Row) (def: (map f xs) - {#level (get@ #level xs) - #size (get@ #size xs) - #root (|> xs (get@ #root) (array\map (\ node_functor map f))) - #tail (|> xs (get@ #tail) (array\map f))})) + {#level (value@ #level xs) + #size (value@ #size xs) + #root (|> xs (value@ #root) (array\map (\ node_functor map f))) + #tail (|> xs (value@ #tail) (array\map f))})) (implementation: .public apply (Apply Row) @@ -469,7 +469,7 @@ (All [a] (-> (Row a) (Row a))) (|>> ..list list.reversed - (list\fold add ..empty))) + (list\fold suffix ..empty))) (template [<name> <array> <init> <op>] [(def: .public <name> diff --git a/stdlib/source/library/lux/data/collection/sequence.lux b/stdlib/source/library/lux/data/collection/sequence.lux index a7d2cc0b4..42cd682df 100644 --- a/stdlib/source/library/lux/data/collection/sequence.lux +++ b/stdlib/source/library/lux/data/collection/sequence.lux @@ -65,7 +65,7 @@ (let [[head tail] (//.result sequence)] (case idx 0 head - _ (item (dec idx) tail)))) + _ (item (-- idx) tail)))) (template [<taker> <dropper> <pred_type> <pred_test> <pred_step> <post_test>] [(def: .public (<taker> pred xs) @@ -85,7 +85,7 @@ xs)))] [while until (-> a Bit) (pred x) pred |>] - [first after Nat (n.= 0 pred) (dec pred) not] + [first after Nat (n.= 0 pred) (-- pred) not] ) (template [<splitter> <pred_type> <pred_test> <pred_step>] @@ -99,7 +99,7 @@ [(#.Item [x tail]) next]))))] [split_when (-> a Bit) (pred x) pred] - [split_at Nat (n.= 0 pred) (dec pred)] + [split_at Nat (n.= 0 pred) (-- pred)] ) (def: .public (only predicate sequence) diff --git a/stdlib/source/library/lux/data/collection/set/ordered.lux b/stdlib/source/library/lux/data/collection/set/ordered.lux index 6ef570c31..28bbf1876 100644 --- a/stdlib/source/library/lux/data/collection/set/ordered.lux +++ b/stdlib/source/library/lux/data/collection/set/ordered.lux @@ -60,13 +60,13 @@ (All [a] (-> (Set a) (Set a) (Set a))) (|> (..list right) (list.only (..member? left)) - (..of_list (get@ #/.&order (:representation right))))) + (..of_list (value@ #/.&order (:representation right))))) (def: .public (difference param subject) (All [a] (-> (Set a) (Set a) (Set a))) (|> (..list subject) (list.only (|>> (..member? param) not)) - (..of_list (get@ #/.&order (:representation subject))))) + (..of_list (value@ #/.&order (:representation subject))))) (implementation: .public equivalence (All [a] (Equivalence (Set a))) diff --git a/stdlib/source/library/lux/data/collection/tree.lux b/stdlib/source/library/lux/data/collection/tree.lux index 451fc6143..112932a50 100644 --- a/stdlib/source/library/lux/data/collection/tree.lux +++ b/stdlib/source/library/lux/data/collection/tree.lux @@ -25,10 +25,10 @@ {#.doc (example "All the leaf values of the tree, in order.")} (All [a] (-> (Tree a) (List a))) (|> tree - (get@ #children) + (value@ #children) (list\map flat) list\join - (#.Item (get@ #value tree)))) + (#.Item (value@ #value tree)))) (def: .public (leaf value) (All [a] (-> a (Tree a))) @@ -69,22 +69,22 @@ (All [a] (-> (Equivalence a) (Equivalence (Tree a)))) (def: (= tx ty) - (and (\ super = (get@ #value tx) (get@ #value ty)) - (\ (list.equivalence (equivalence super)) = (get@ #children tx) (get@ #children ty))))) + (and (\ super = (value@ #value tx) (value@ #value ty)) + (\ (list.equivalence (equivalence super)) = (value@ #children tx) (value@ #children ty))))) (implementation: .public functor (Functor Tree) (def: (map f fa) - {#value (f (get@ #value fa)) + {#value (f (value@ #value fa)) #children (list\map (map f) - (get@ #children fa))})) + (value@ #children fa))})) (implementation: .public fold (Fold Tree) (def: (fold f init tree) (list\fold (function (_ tree' init') (fold f init' tree')) - (f (get@ #value tree) + (f (value@ #value tree) init) - (get@ #children tree)))) + (value@ #children tree)))) diff --git a/stdlib/source/library/lux/data/collection/tree/finger.lux b/stdlib/source/library/lux/data/collection/tree/finger.lux index 9c2844be7..588cb4e5a 100644 --- a/stdlib/source/library/lux/data/collection/tree/finger.lux +++ b/stdlib/source/library/lux/data/collection/tree/finger.lux @@ -33,7 +33,7 @@ (template [<name> <tag> <output>] [(def: .public <name> (All [@ t v] (-> (Tree @ t v) <output>)) - (|>> :representation (get@ <tag>)))] + (|>> :representation (value@ <tag>)))] [tag #tag t] [root #root (Either v [(Tree @ t v) (Tree @ t v)])] @@ -57,7 +57,7 @@ (def: .public (value tree) (All [@ t v] (-> (Tree @ t v) v)) - (case (get@ #root (:representation tree)) + (case (value@ #root (:representation tree)) (0 #0 value) value @@ -66,9 +66,9 @@ (def: .public (tags tree) (All [@ t v] (-> (Tree @ t v) (List t))) - (case (get@ #root (:representation tree)) + (case (value@ #root (:representation tree)) (0 #0 value) - (list (get@ #tag (:representation tree))) + (list (value@ #tag (:representation tree))) (0 #1 [left right]) (list\compose (tags left) @@ -76,7 +76,7 @@ (def: .public (values tree) (All [@ t v] (-> (Tree @ t v) (List v))) - (case (get@ #root (:representation tree)) + (case (value@ #root (:representation tree)) (0 #0 value) (list value) @@ -99,8 +99,8 @@ (0 #1 [left right]) (let [shifted_tag (tag//compose _tag (..tag left))] (if (predicate shifted_tag) - (recur _tag (get@ #root (:representation left))) - (recur shifted_tag (get@ #root (:representation right)))))))) + (recur _tag (value@ #root (:representation left))) + (recur shifted_tag (value@ #root (:representation right)))))))) #.None))) ) diff --git a/stdlib/source/library/lux/data/collection/tree/zipper.lux b/stdlib/source/library/lux/data/collection/tree/zipper.lux index b6fb27355..6d1709c55 100644 --- a/stdlib/source/library/lux/data/collection/tree/zipper.lux +++ b/stdlib/source/library/lux/data/collection/tree/zipper.lux @@ -50,23 +50,23 @@ (def: .public tree (All [a] (-> (Zipper a) (Tree a))) - (get@ #node)) + (value@ #node)) (def: .public value (All [a] (-> (Zipper a) a)) - (get@ [#node #//.value])) + (value@ [#node #//.value])) (def: .public (set value zipper) (All [a] (-> a (Zipper a) (Zipper a))) - (set@ [#node #//.value] value zipper)) + (with@ [#node #//.value] value zipper)) (def: .public (update transform zipper) (All [a] (-> (-> a a) (Zipper a) (Zipper a))) - (update@ [#node #//.value] transform zipper)) + (revised@ [#node #//.value] transform zipper)) (def: children (All [a] (-> (Zipper a) (List (Tree a)))) - (get@ [#node #//.children])) + (value@ [#node #//.children])) (def: .public leaf? (All [a] (-> (Zipper a) Bit)) @@ -78,7 +78,7 @@ (def: .public (start? zipper) (All [a] (-> (Zipper a) Bit)) - (case (get@ #family zipper) + (case (value@ #family zipper) #.None true @@ -92,7 +92,7 @@ #.None (#.Item head tail) - (#.Some {#family (#.Some {#parent (set@ [#node #//.children] (list) zipper) + (#.Some {#family (#.Some {#parent (with@ [#node #//.children] (list) zipper) #lefts #.End #rights tail}) #node head}))) @@ -100,37 +100,37 @@ (def: .public (up zipper) (All [a] (-> (Zipper a) (Maybe (Zipper a)))) (do maybe.monad - [family (get@ #family zipper)] + [family (value@ #family zipper)] (in (let [(^slots [#parent #lefts #rights]) family] (for {@.old - (update@ #node (: (-> (Tree (:parameter 0)) - (Tree (:parameter 0))) - (set@ #//.children (list\compose (list.reversed lefts) - (#.Item (get@ #node zipper) - rights)))) - parent)} - (set@ [#node #//.children] - (list\compose (list.reversed lefts) - (#.Item (get@ #node zipper) - rights)) - parent)))))) + (revised@ #node (: (-> (Tree (:parameter 0)) + (Tree (:parameter 0))) + (with@ #//.children (list\compose (list.reversed lefts) + (#.Item (value@ #node zipper) + rights)))) + parent)} + (with@ [#node #//.children] + (list\compose (list.reversed lefts) + (#.Item (value@ #node zipper) + rights)) + parent)))))) (template [<one> <all> <side> <op_side>] [(def: .public (<one> zipper) (All [a] (-> (Zipper a) (Maybe (Zipper a)))) - (case (get@ #family zipper) + (case (value@ #family zipper) (#.Some family) - (case (get@ <side> family) + (case (value@ <side> family) (#.Item next side') (#.Some (for {@.old {#family (#.Some (|> family - (set@ <side> side') - (update@ <op_side> (|>> (#.Item (get@ #node zipper)))))) + (with@ <side> side') + (revised@ <op_side> (|>> (#.Item (value@ #node zipper)))))) #node next}} (let [move (: (All [a] (-> (List (Tree a)) (Zipper a) (Family Zipper a) (Family Zipper a))) (function (_ side' zipper) - (|>> (set@ <side> side') - (update@ <op_side> (|>> (#.Item (get@ #node zipper)))))))] + (|>> (with@ <side> side') + (revised@ <op_side> (|>> (#.Item (value@ #node zipper)))))))] {#family (#.Some (move side' zipper family)) #node next}))) @@ -142,26 +142,26 @@ (def: .public (<all> zipper) (All [a] (-> (Zipper a) (Maybe (Zipper a)))) - (case (get@ #family zipper) + (case (value@ #family zipper) #.None #.None (#.Some family) - (case (list.reversed (get@ <side> family)) + (case (list.reversed (value@ <side> family)) #.End #.None (#.Item last prevs) (#.Some (for {@.old {#family (#.Some (|> family - (set@ <side> #.End) - (update@ <op_side> (|>> (#.Item (get@ #node zipper)) - (list\compose prevs))))) + (with@ <side> #.End) + (revised@ <op_side> (|>> (#.Item (value@ #node zipper)) + (list\compose prevs))))) #node last}} (let [move (: (All [a] (-> (List (Tree a)) (Zipper a) (Family Zipper a) (Family Zipper a))) (function (_ prevs zipper) - (|>> (set@ <side> #.End) - (update@ <op_side> (|>> (#.Item (get@ #node zipper)) - (list\compose prevs))))))] + (|>> (with@ <side> #.End) + (revised@ <op_side> (|>> (#.Item (value@ #node zipper)) + (list\compose prevs))))))] {#family (#.Some (move prevs zipper family)) #node last}))))))] @@ -245,44 +245,44 @@ (def: .public (interpose value zipper) (All [a] (-> a (Zipper a) (Zipper a))) - (update@ [#node #//.children] - (|>> (//.branch value) list) - zipper)) + (revised@ [#node #//.children] + (|>> (//.branch value) list) + zipper)) (def: .public (adopt value zipper) (All [a] (-> a (Zipper a) (Zipper a))) - (update@ [#node #//.children] - (|>> (#.Item (//.leaf value))) - zipper)) + (revised@ [#node #//.children] + (|>> (#.Item (//.leaf value))) + zipper)) (def: .public (remove zipper) (All [a] (-> (Zipper a) (Maybe (Zipper a)))) (do maybe.monad - [family (get@ #family zipper)] - (case (get@ #lefts family) + [family (value@ #family zipper)] + (case (value@ #lefts family) #.End - (in (set@ [#node #//.children] - (get@ #rights family) - (get@ #parent family))) + (in (with@ [#node #//.children] + (value@ #rights family) + (value@ #parent family))) (#.Item next side) (in (|> zipper - (set@ #family (|> family - (set@ #lefts side) - #.Some)) - (set@ #node next)))))) + (with@ #family (|> family + (with@ #lefts side) + #.Some)) + (with@ #node next)))))) (template [<name> <side>] [(def: .public (<name> value zipper) (All [a] (-> a (Zipper a) (Maybe (Zipper a)))) - (case (get@ #family zipper) + (case (value@ #family zipper) #.None #.None (#.Some family) - (#.Some (set@ #family - (#.Some (update@ <side> (|>> (#.Item (//.leaf value))) family)) - zipper))))] + (#.Some (with@ #family + (#.Some (revised@ <side> (|>> (#.Item (//.leaf value))) family)) + zipper))))] [insert_left #lefts] [insert_right #rights] @@ -304,14 +304,14 @@ (def: &functor ..functor) - (def: out (get@ [#node #//.value])) + (def: out (value@ [#node #//.value])) (def: (split (^slots [#family #node])) (let [tree_splitter (: (All [a] (-> (Tree a) (Tree (Zipper a)))) (function (tree_splitter tree) {#//.value (..zipper tree) #//.children (|> tree - (get@ #//.children) + (value@ #//.children) (list\map tree_splitter))}))] {#family (maybe\map (function (_ (^slots [#parent #lefts #rights])) {#parent (split parent) diff --git a/stdlib/source/library/lux/data/color.lux b/stdlib/source/library/lux/data/color.lux index 19cdb0b66..1cebc0408 100644 --- a/stdlib/source/library/lux/data/color.lux +++ b/stdlib/source/library/lux/data/color.lux @@ -28,7 +28,7 @@ abstract]]]) (def: rgb_limit 256) -(def: top (dec rgb_limit)) +(def: top (-- rgb_limit)) (def: rgb_factor (|> top .int int.frac)) @@ -420,7 +420,7 @@ (let [[hue saturation brightness] (hsb color) spread (..normal spread)] (list\map (function (_ idx) - (of_hsb [(|> idx inc .int int.frac (f.* spread) (f.+ hue) ..normal) + (of_hsb [(|> idx ++ .int int.frac (f.* spread) (f.+ hue) ..normal) saturation brightness])) (list.indices variations))))) @@ -431,7 +431,7 @@ (let [[hue saturation brightness] (hsb color) spread (..normal spread)] (|> (list.indices variations) - (list\map (|>> inc .int int.frac + (list\map (|>> ++ .int int.frac (f.* spread) (f.+ brightness) ..normal diff --git a/stdlib/source/library/lux/data/format/binary.lux b/stdlib/source/library/lux/data/format/binary.lux index e23ade3fb..7a6ccadba 100644 --- a/stdlib/source/library/lux/data/format/binary.lux +++ b/stdlib/source/library/lux/data/format/binary.lux @@ -93,12 +93,12 @@ (^template [<number> <tag> <writer>] [(<tag> caseV) (let [[caseS caseT] (<writer> caseV)] - [(.inc caseS) + [(.++ caseS) (function (_ [offset binary]) (|> binary (binary.write/8! offset <number>) try.trusted - [(.inc offset)] + [(.++ offset)] caseT))])]) ([0 #.Left left] [1 #.Right right]) @@ -243,12 +243,12 @@ (^template [<number> <tag> <writer>] [(<tag> caseV) (let [[caseS caseT] (<writer> caseV)] - [(.inc caseS) + [(.++ caseS) (function (_ [offset binary]) (|> binary (binary.write/8! offset <number>) try.trusted - [(.inc offset)] + [(.++ offset)] caseT))])]) ([0 #.Primitive (..and ..text (..list recur))] [1 #.Sum pair] @@ -278,12 +278,12 @@ (^template [<number> <tag> <writer>] [(<tag> caseV) (let [[caseS caseT] (<writer> caseV)] - [(.inc caseS) + [(.++ caseS) (function (_ [offset binary]) (|> binary (binary.write/8! offset <number>) try.trusted - [(.inc offset)] + [(.++ offset)] caseT))])]) ([0 #.Bit ..bit] [1 #.Nat ..nat] diff --git a/stdlib/source/library/lux/data/format/css.lux b/stdlib/source/library/lux/data/format/css.lux index 7ec9a0d35..8b3a9270c 100644 --- a/stdlib/source/library/lux/data/format/css.lux +++ b/stdlib/source/library/lux/data/format/css.lux @@ -51,19 +51,19 @@ (def: .public (font font) (-> Font (CSS Special)) - (let [with_unicode (case (get@ #/font.unicode_range font) + (let [with_unicode (case (value@ #/font.unicode_range font) (#.Some unicode_range) - (let [unicode_range' (format "U+" (\ nat.hex encode (get@ #/font.start unicode_range)) - "-" (\ nat.hex encode (get@ #/font.end unicode_range)))] + (let [unicode_range' (format "U+" (\ nat.hex encode (value@ #/font.start unicode_range)) + "-" (\ nat.hex encode (value@ #/font.end unicode_range)))] (list ["unicode-range" unicode_range'])) #.None (list))] - (|> (list& ["font-family" (get@ #/font.family font)] - ["src" (format "url(" (get@ #/font.source font) ")")] - ["font-stretch" (|> font (get@ #/font.stretch) (maybe.else /value.normal_stretch) /value.value)] - ["font-style" (|> font (get@ #/font.style) (maybe.else /value.normal_style) /value.value)] - ["font-weight" (|> font (get@ #/font.weight) (maybe.else /value.normal_weight) /value.value)] + (|> (list& ["font-family" (value@ #/font.family font)] + ["src" (format "url(" (value@ #/font.source font) ")")] + ["font-stretch" (|> font (value@ #/font.stretch) (maybe.else /value.normal_stretch) /value.value)] + ["font-style" (|> font (value@ #/font.style) (maybe.else /value.normal_style) /value.value)] + ["font-weight" (|> font (value@ #/font.weight) (maybe.else /value.normal_weight) /value.value)] with_unicode) (list\map (function (_ [property value]) (format property ": " value ";"))) @@ -95,8 +95,8 @@ (:abstraction (format "@keyframes " (/value.value animation) " {" (|> frames (list\map (function (_ frame) - (format (/value.percentage (get@ #when frame)) " {" - (/style.inline (get@ #what frame)) + (format (/value.percentage (value@ #when frame)) " {" + (/style.inline (value@ #what frame)) "}"))) (text.interposed ..css_separator)) "}"))) diff --git a/stdlib/source/library/lux/data/format/css/value.lux b/stdlib/source/library/lux/data/format/css/value.lux index 0c8e8f70f..54de6d97a 100644 --- a/stdlib/source/library/lux/data/format/css/value.lux +++ b/stdlib/source/library/lux/data/format/css/value.lux @@ -988,7 +988,7 @@ (-> Percentage Text) (|>> :representation)) - (def: percentage_limit Nat (.inc 100)) + (def: percentage_limit Nat (.++ 100)) (def: .public (%% value) (-> Nat Percentage) @@ -1131,7 +1131,7 @@ (def: .public (clip rectangle) (-> Rectangle (Value Clip)) (`` (..apply "rect" (list (~~ (template [<side>] - [(:representation (get@ <side> rectangle))] + [(:representation (value@ <side> rectangle))] [#top] [#right] [#bottom] [#left])))))) diff --git a/stdlib/source/library/lux/data/format/tar.lux b/stdlib/source/library/lux/data/format/tar.lux index 7f1346df1..c26a7a751 100644 --- a/stdlib/source/library/lux/data/format/tar.lux +++ b/stdlib/source/library/lux/data/format/tar.lux @@ -44,7 +44,7 @@ max_size) padding (|> "0" (list.repeated padding_size) - text.joined)] + text.together)] (format padding number))) (def: blank " ") @@ -61,12 +61,12 @@ (|> ..octal_size (list.repeated <size>) (list\fold n.* 1) - inc)) + ++)) (exception: .public (<exception> {value Nat}) (exception.report ["Value" (%.nat value)] - ["Maximum" (%.nat (dec <limit>))])) + ["Maximum" (%.nat (-- <limit>))])) (abstract: .public <type> {} @@ -171,7 +171,7 @@ (def: checksum (-> Binary Nat) - (binary.fold n.+ 0)) + (binary.aggregate n.+ 0)) (def: checksum_checksum (|> ..dummy_checksum @@ -216,10 +216,10 @@ (def: ascii? (-> Text Bit) (|>> (\ utf8.codec encode) - (binary.fold (function (_ char verdict) - (.and verdict - (n.<= ..last_ascii char))) - true))) + (binary.aggregate (function (_ char verdict) + (.and verdict + (n.<= ..last_ascii char))) + true))) (exception: .public (not_ascii {text Text}) (exception.report @@ -232,17 +232,17 @@ (-> Binary (Try Binary)) (case (binary.size string) 0 (#try.Success string) - size (loop [end (dec size)] + size (loop [end (-- size)] (case end 0 (#try.Success (\ utf8.codec encode "")) _ (do try.monad [last_char (binary.read/8! end string)] (`` (case (.nat last_char) (^ (char (~~ (static ..null)))) - (recur (dec end)) + (recur (-- end)) _ - (binary.slice 0 (inc end) string)))))))) + (binary.slice 0 (++ end) string)))))))) (template [<type> <representation> <size> <exception> <in> <out> <writer> <parser> <none>] [(abstract: .public <type> @@ -640,11 +640,11 @@ (def: (header_writer header) (Writer Header) (let [checksum (|> header - (set@ #checksum ..dummy_checksum) + (with@ #checksum ..dummy_checksum) (format.result ..header_writer') ..checksum_code)] (|> header - (set@ #checksum checksum) + (with@ #checksum checksum) (format.result ..header_writer') (format.segment ..block_size)))) @@ -664,16 +664,16 @@ (format.segment (..rounded_content_size size)))] (writer [{#path path #mode mode - #user_id (get@ [#user #id] ownership) - #group_id (get@ [#group #id] ownership) + #user_id (value@ [#user #id] ownership) + #group_id (value@ [#group #id] ownership) #size size #modification_time (..modification_time modification_time) #checksum ..dummy_checksum #link_flag link_flag #link_name ..no_path #magic ..ustar - #user_name (get@ [#user #name] ownership) - #group_name (get@ [#group #name] ownership) + #user_name (value@ [#user #name] ownership) + #group_name (value@ [#group #name] ownership) #major_device ..no_device #minor_device ..no_device} content])))) @@ -812,26 +812,26 @@ (-> Link_Flag (Parser File)) (do <>.monad [header ..header_parser - _ (<>.assertion (exception.error ..wrong_link_flag [expected (get@ #link_flag header)]) - (same? expected (get@ #link_flag header))) - .let [size (get@ #size header) + _ (<>.assertion (exception.error ..wrong_link_flag [expected (value@ #link_flag header)]) + (same? expected (value@ #link_flag header))) + .let [size (value@ #size header) rounded_size (..rounded_content_size size)] content (<binary>.segment (..from_big size)) content (<>.lifted (..content content)) _ (<binary>.segment (n.- (..from_big size) rounded_size))] - (in [(get@ #path header) + (in [(value@ #path header) (|> header - (get@ #modification_time) + (value@ #modification_time) ..from_big .int duration.of_millis (duration.up (|> duration.second duration.millis .nat)) instant.absolute) - (get@ #mode header) - {#user {#name (get@ #user_name header) - #id (get@ #user_id header)} - #group {#name (get@ #group_name header) - #id (get@ #group_id header)}} + (value@ #mode header) + {#user {#name (value@ #user_name header) + #id (value@ #user_id header)} + #group {#name (value@ #group_name header) + #id (value@ #group_id header)}} content]))) (def: (file_name_parser expected extractor) @@ -839,9 +839,9 @@ (do <>.monad [header ..header_parser _ (<>.lifted - (exception.assertion ..wrong_link_flag [expected (get@ #link_flag header)] + (exception.assertion ..wrong_link_flag [expected (value@ #link_flag header)] (n.= (..link_flag expected) - (..link_flag (get@ #link_flag header)))))] + (..link_flag (value@ #link_flag header)))))] (in (extractor header)))) (def: entry_parser @@ -851,9 +851,9 @@ (<>.either (..file_parser ..normal) (..file_parser ..old_normal))) (\ <>.monad map (|>> #..Symbolic_Link) - (..file_name_parser ..symbolic_link (get@ #link_name))) + (..file_name_parser ..symbolic_link (value@ #link_name))) (\ <>.monad map (|>> #..Directory) - (..file_name_parser ..directory (get@ #path))) + (..file_name_parser ..directory (value@ #path))) (\ <>.monad map (|>> #..Contiguous) (..file_parser ..contiguous)))) diff --git a/stdlib/source/library/lux/data/format/xml.lux b/stdlib/source/library/lux/data/format/xml.lux index 67722607c..b596734ea 100644 --- a/stdlib/source/library/lux/data/format/xml.lux +++ b/stdlib/source/library/lux/data/format/xml.lux @@ -269,7 +269,7 @@ ($_ text\compose prefix "<" tag attrs ">" (|> xml_children (list\map (|>> (recur (text\compose prefix text.tab)) (text\compose text.new_line))) - text.joined) + text.together) text.new_line prefix "</" tag ">"))))) )))) (def: decode diff --git a/stdlib/source/library/lux/data/product.lux b/stdlib/source/library/lux/data/product.lux index 4173f8133..aba9488bc 100644 --- a/stdlib/source/library/lux/data/product.lux +++ b/stdlib/source/library/lux/data/product.lux @@ -41,7 +41,7 @@ (let [[x y] xy] [y x])) -(def: .public (apply f g) +(def: .public (then f g) {#.doc (example "Apply functions to both sides of a pair.")} (All [a b c d] (-> (-> a c) (-> b d) @@ -49,7 +49,7 @@ (function (_ [x y]) [(f x) (g y)])) -(def: .public (fork f g) +(def: .public (forked f g) {#.doc (example "Yields a pair by applying both functions to a single value.")} (All [a l r] (-> (-> a l) (-> a r) diff --git a/stdlib/source/library/lux/data/store.lux b/stdlib/source/library/lux/data/store.lux index ba795f4d1..a25331cd4 100644 --- a/stdlib/source/library/lux/data/store.lux +++ b/stdlib/source/library/lux/data/store.lux @@ -13,8 +13,8 @@ (def: (extend f wa) (All [s a b] (-> (-> (Store s a) b) (Store s a) (Store s b))) - {#cursor (get@ #cursor wa) - #peek (function (_ s) (f (set@ #cursor s wa)))}) + {#cursor (value@ #cursor wa) + #peek (function (_ s) (f (with@ #cursor s wa)))}) (implementation: .public functor (All [s] (Functor (Store s))) diff --git a/stdlib/source/library/lux/data/sum.lux b/stdlib/source/library/lux/data/sum.lux index 84b19ffc3..f14efa463 100644 --- a/stdlib/source/library/lux/data/sum.lux +++ b/stdlib/source/library/lux/data/sum.lux @@ -28,7 +28,7 @@ (0 #0 l) (fl l) (0 #1 r) (fr r)))) -(def: .public (apply fl fr) +(def: .public (then fl fr) {#.doc (example "Applies functions to both sides of a 2-variant.")} (All [l l' r r'] (-> (-> l l') (-> r r') diff --git a/stdlib/source/library/lux/data/text.lux b/stdlib/source/library/lux/data/text.lux index 2670bdae3..baeade224 100644 --- a/stdlib/source/library/lux/data/text.lux +++ b/stdlib/source/library/lux/data/text.lux @@ -78,7 +78,7 @@ output (#.Some from') - (recur (inc from') output'))))) + (recur (++ from') output'))))) (def: .public (last_index_of part text) (-> Text Text (Maybe Nat)) @@ -284,14 +284,14 @@ (loop [index 0 hash 0] (if (n.< length index) - (recur (inc index) + (recur (++ index) (|> hash (i64.left_shifted 5) (n.- hash) (n.+ ("lux text char" index input)))) hash)))))) -(def: .public joined +(def: .public together (-> (List Text) Text) (let [(^open ".") ..monoid] (|>> list.reversed @@ -300,8 +300,8 @@ (def: .public (interposed separator texts) (-> Text (List Text) Text) (case separator - "" (..joined texts) - _ (|> texts (list.interposed separator) ..joined))) + "" (..together texts) + _ (|> texts (list.interposed separator) ..together))) (def: .public (empty? text) (-> Text Bit) diff --git a/stdlib/source/library/lux/data/text/buffer.lux b/stdlib/source/library/lux/data/text/buffer.lux index 2d8708c58..196227220 100644 --- a/stdlib/source/library/lux/data/text/buffer.lux +++ b/stdlib/source/library/lux/data/text/buffer.lux @@ -67,37 +67,37 @@ ... default row.empty)))) - (def: .public (append chunk buffer) + (def: .public (then chunk buffer) (-> Text Buffer Buffer) (with_expansions [<jvm> (let [[capacity transform] (:representation buffer) - append! (: (-> Text java/lang/StringBuilder java/lang/StringBuilder) - (function (_ chunk builder) - (exec - (java/lang/Appendable::append (:as java/lang/CharSequence chunk) - builder) - builder)))] + then! (: (-> Text java/lang/StringBuilder java/lang/StringBuilder) + (function (_ chunk builder) + (exec + (java/lang/Appendable::append (:as java/lang/CharSequence chunk) + builder) + builder)))] (:abstraction [(n.+ (//.size chunk) capacity) - (|>> transform (append! chunk))]))] + (|>> transform (then! chunk))]))] (for {@.old <jvm> @.jvm <jvm> @.js (let [[capacity transform] (:representation buffer) - append! (: (-> (JS_Array Text) (JS_Array Text)) - (function (_ array) - (exec - (JS_Array::push [chunk] array) - array)))] + then! (: (-> (JS_Array Text) (JS_Array Text)) + (function (_ array) + (exec + (JS_Array::push [chunk] array) + array)))] (:abstraction [(n.+ (//.size chunk) capacity) - (|>> transform append!)])) + (|>> transform then!)])) @.lua (let [[capacity transform] (:representation buffer) - append! (: (-> (array.Array Text) (array.Array Text)) - (function (_ array) - (exec - (table/insert [array chunk]) - array)))] + then! (: (-> (array.Array Text) (array.Array Text)) + (function (_ array) + (exec + (table/insert [array chunk]) + array)))] (:abstraction [(n.+ (//.size chunk) capacity) - (|>> transform append!)]))} + (|>> transform then!)]))} ... default - (|> buffer :representation (row.add chunk) :abstraction)))) + (|> buffer :representation (row.suffix chunk) :abstraction)))) (def: .public size (-> Buffer Nat) diff --git a/stdlib/source/library/lux/data/text/escape.lux b/stdlib/source/library/lux/data/text/escape.lux index f46331176..89205cbff 100644 --- a/stdlib/source/library/lux/data/text/escape.lux +++ b/stdlib/source/library/lux/data/text/escape.lux @@ -84,7 +84,7 @@ (def: (ascii_escaped replacement pre_offset pre_limit previous current) (-> Text Nat Nat Text Text [Text Text Nat]) - (let [post_offset (inc pre_offset) + (let [post_offset (++ pre_offset) post_limit (n.- post_offset pre_limit)] [(format previous ("lux text clip" 0 pre_offset current) @@ -101,7 +101,7 @@ 2 (format "00" code) 3 (format "0" code) _ code)) - post_offset (inc pre_offset) + post_offset (++ pre_offset) post_limit (n.- post_offset pre_limit)] [(format previous ("lux text clip" 0 pre_offset current) @@ -138,13 +138,13 @@ (n.> ..ascii_top char)) (let [[previous' current' limit'] (unicode_escaped char offset limit previous current)] (recur 0 previous' current' limit')) - (recur (inc offset) previous current limit))) + (recur (++ offset) previous current limit))) (format previous current)))) (exception: .public (dangling_escape {text Text}) (exception.report ["In" (%.text text)] - ["At" (%.nat (dec (//.size text)))])) + ["At" (%.nat (-- (//.size text)))])) (exception: .public (invalid_escape {text Text} {offset Nat} {sigil Char}) (exception.report @@ -202,7 +202,7 @@ (if (n.< limit offset) (case ("lux text char" offset current) (^ (static ..sigil_char)) - (let [@sigil (inc offset)] + (let [@sigil (++ offset)] (if (n.< limit @sigil) (case ("lux text char" @sigil current) (^template [<sigil> <un_escaped>] @@ -233,7 +233,7 @@ (exception.except ..dangling_escape [text]))) _ - (recur (inc offset) previous current limit)) + (recur (++ offset) previous current limit)) (#try.Success (case previous "" current _ (format previous current)))))) diff --git a/stdlib/source/library/lux/data/text/format.lux b/stdlib/source/library/lux/data/text/format.lux index 1a274b692..894dd8321 100644 --- a/stdlib/source/library/lux/data/text/format.lux +++ b/stdlib/source/library/lux/data/text/format.lux @@ -121,7 +121,7 @@ (def: .public (list formatter) (All [a] (-> (Format a) (Format (List a)))) (|>> (list\map (|>> formatter (format " "))) - text.joined + text.together (text.enclosed ["(list" ")"]))) (def: .public (maybe format) diff --git a/stdlib/source/library/lux/data/text/regex.lux b/stdlib/source/library/lux/data/text/regex.lux index 4998e9ce9..3b26dac8e 100644 --- a/stdlib/source/library/lux/data/text/regex.lux +++ b/stdlib/source/library/lux/data/text/regex.lux @@ -54,7 +54,7 @@ (def: join_text^ (-> (Parser (List Text)) (Parser Text)) - (\ <>.monad map //.joined)) + (\ <>.monad map //.together)) (def: name_char^ (Parser Text) @@ -300,7 +300,7 @@ [idx (code.identifier ["" _name])] #.None - [(inc idx) (code.identifier ["" (n\encode idx)])]) + [(++ idx) (code.identifier ["" (n\encode idx)])]) access (if (n.> 0 num_captures) (` ((~! product.left) (~ name!))) name!)] diff --git a/stdlib/source/library/lux/data/text/unicode/block.lux b/stdlib/source/library/lux/data/text/unicode/block.lux index deb289a22..95931ff4a 100644 --- a/stdlib/source/library/lux/data/text/unicode/block.lux +++ b/stdlib/source/library/lux/data/text/unicode/block.lux @@ -48,7 +48,7 @@ (template [<name> <slot>] [(def: .public <name> (-> Block Char) - (|>> :representation (get@ <slot>)))] + (|>> :representation (value@ <slot>)))] [start #interval.bottom] [end #interval.top] @@ -56,9 +56,9 @@ (def: .public (size block) (-> Block Nat) - (let [start (get@ #interval.bottom (:representation block)) - end (get@ #interval.top (:representation block))] - (|> end (n.- start) inc))) + (let [start (value@ #interval.bottom (:representation block)) + end (value@ #interval.top (:representation block))] + (|> end (n.- start) ++))) (def: .public (within? block char) (All [a] (-> Block Char Bit)) diff --git a/stdlib/source/library/lux/data/trace.lux b/stdlib/source/library/lux/data/trace.lux index 8917fc89a..4b5da0b54 100644 --- a/stdlib/source/library/lux/data/trace.lux +++ b/stdlib/source/library/lux/data/trace.lux @@ -13,22 +13,22 @@ (implementation: .public functor (All [t] (Functor (Trace t))) (def: (map f fa) - (update@ #trace (compose f) fa))) + (revised@ #trace (compose f) fa))) (implementation: .public comonad (All [t] (CoMonad (Trace t))) (def: &functor ..functor) (def: (out wa) - ((get@ #trace wa) - (get@ [#monoid #monoid.identity] wa))) + ((value@ #trace wa) + (value@ [#monoid #monoid.identity] wa))) (def: (split wa) - (let [monoid (get@ #monoid wa)] + (let [monoid (value@ #monoid wa)] {#monoid monoid #trace (function (_ t1) {#monoid monoid #trace (function (_ t2) - ((get@ #trace wa) + ((value@ #trace wa) (\ monoid compose t1 t2)))})}))) (def: .public (result context tracer) diff --git a/stdlib/source/library/lux/debug.lux b/stdlib/source/library/lux/debug.lux index 8183fb6ff..7a5a9a153 100644 --- a/stdlib/source/library/lux/debug.lux +++ b/stdlib/source/library/lux/debug.lux @@ -126,7 +126,7 @@ (let [member ("lua array read" idx tuple)] (if ("lua object nil?" member) #.End - (#.Item member (recur (inc idx))))))))} + (#.Item member (recur (++ idx))))))))} (as_is)) (def: (tuple_inspection inspection) @@ -461,7 +461,7 @@ [lefts #1 (rightR right)] _ - (recur (inc lefts) (#.Item rightR extraR+) right))) + (recur (++ lefts) (#.Item rightR extraR+) right))) _ (undefined)))] @@ -601,7 +601,7 @@ [location meta.location locals meta.locals .let [environment (|> locals - list.joined + list.together ... The list is reversed to make sure that, when building the dictionary, ... later bindings overshadow earlier ones if they have the same name. list.reversed diff --git a/stdlib/source/library/lux/documentation.lux b/stdlib/source/library/lux/documentation.lux index 8651dbdcc..37147b2f0 100644 --- a/stdlib/source/library/lux/documentation.lux +++ b/stdlib/source/library/lux/documentation.lux @@ -2,6 +2,7 @@ [library [lux (#- Definition Module example type) ["." meta] + ["." type ("#\." equivalence)] [abstract [monad (#+ do)]] [control @@ -18,7 +19,7 @@ ["." set (#+ Set)]] [format ["md" markdown (#+ Markdown Block)]]] - [macro + ["." macro [syntax (#+ syntax:)] ["." code] ["." template]] @@ -74,13 +75,13 @@ (if (n.= old_line new_line) (if (n.< old_column new_column) "" - (text.joined (list.repeated (n.- old_column new_column) " "))) + (text.together (list.repeated (n.- old_column new_column) " "))) (format (if (n.< old_line new_line) "" - (text.joined (list.repeated (n.- old_line new_line) \n))) + (text.together (list.repeated (n.- old_line new_line) \n))) (if (n.< reference_column new_column) "" - (text.joined (list.repeated (n.- reference_column new_column) " ")))))) + (text.together (list.repeated (n.- reference_column new_column) " ")))))) (def: un_paired (All [a] (-> (List [a a]) (List a))) @@ -96,7 +97,7 @@ (^template [<tag> <format>] [[new_location (<tag> value)] (let [documentation (`` (|> value (~~ (template.spliced <format>))))] - [(update@ #.column (n.+ (text.size documentation)) new_location) + [(revised@ #.column (n.+ (text.size documentation)) new_location) (format (padding reference_column old_location new_location) documentation)])]) ([#.Bit [%.bit]] @@ -113,9 +114,9 @@ (let [[group_location' members_documentation] (list\fold (function (_ part [last_location text_accum]) (let [[member_location member_documentation] (code_documentation last_location reference_column part)] [member_location (format text_accum member_documentation)])) - [(update@ #.column inc group_location) ""] + [(revised@ #.column ++ group_location) ""] (<prep> members))] - [(update@ #.column inc group_location') + [(revised@ #.column ++ group_location') (format (padding reference_column old_location group_location) |<| members_documentation |>|)])]) ([syntax.open_form syntax.close_form #.Form |>] @@ -141,7 +142,7 @@ (let [reference_column (..reference_column example) [location _] example] (|> example - (..code_documentation (set@ #.column reference_column location) reference_column) + (..code_documentation (with@ #.column reference_column location) reference_column) product.right)))) (def: type @@ -194,16 +195,26 @@ (syntax: (minimal_definition_documentation [name ..qualified_identifier]) (with_expansions [<\n> (~! text.\n)] - (in (list (` ($_ ((~! md.then)) - ... Name - (<| ((~! md.heading/3)) - (~ (code.text (|> name product.right [""] %.name)))) - ... Type - (<| ((~! md.code)) - ((~! ..type) ("lux in-module" - (~ (code.text (product.left name))) - (.:of (~ (code.identifier name))))))) - ))))) + (macro.with_identifiers [g!type] + (in (list (` ($_ ((~! md.then)) + ... Name + (<| ((~! md.heading/3)) + (~ (code.text (|> name product.right [""] %.name)))) + ... Type + (let [(~ g!type) ("lux in-module" + (~ (code.text (product.left name))) + (.:of (~ (code.identifier name))))] + ((~! md.code) + (if ((~! type\=) .Type (~ g!type)) + (|> (~ (code.identifier name)) + (:as .Type) + ((~! type.anonymous)) + ((~! ..type)) + ((~! %.format) + ((~! ..single_line_comment) ((~! ..type) (~ g!type))) + <\n>)) + ((~! ..type) (~ g!type)))))) + )))))) (syntax: (definition_documentation [name ..qualified_identifier @@ -265,9 +276,9 @@ (def: definitions_documentation (-> (List Definition) (Markdown Block)) (|>> (list.sorted (function (_ left right) - (text\< (get@ #definition right) - (get@ #definition left)))) - (list\map (get@ #documentation)) + (text\< (value@ #definition right) + (value@ #definition left)))) + (list\map (value@ #documentation)) (list\fold md.then md.empty))) (def: expected_separator @@ -326,23 +337,25 @@ (let [(^slots [#expected]) module] ($_ md.then ... Name - (md.heading/1 (get@ #module module)) + (md.heading/1 (value@ #module module)) ... Description - (<| md.paragraph - md.text - (get@ #description module)) + (case (value@ #description module) + "" md.empty + description (<| md.paragraph + md.text + description)) ... Definitions (md.heading/2 "Definitions") (|> module - (get@ #definitions) - (list.only (|>> (get@ #definition) + (value@ #definitions) + (list.only (|>> (value@ #definition) (set.member? expected))) ..definitions_documentation) ... Missing documentation (case (|> module - (get@ #definitions) + (value@ #definitions) (list\fold (function (_ definition missing) - (set.lacks (get@ #definition definition) missing)) + (set.lacks (value@ #definition definition) missing)) expected) set.list) #.End @@ -354,9 +367,9 @@ (..listing missing))) ... Un-expected documentation (case (|> module - (get@ #definitions) - (list.only (|>> (get@ #definition) (set.member? expected) not)) - (list\map (get@ #definition))) + (value@ #definitions) + (list.only (|>> (value@ #definition) (set.member? expected) not)) + (list\map (value@ #definition))) #.End md.empty @@ -369,7 +382,7 @@ (def: .public documentation (-> (List Module) Text) (|>> (list.sorted (function (_ left right) - (text\< (get@ #module right) (get@ #module left)))) + (text\< (value@ #module right) (value@ #module left)))) (list\map ..module_documentation) (list.interposed md.horizontal_rule) (list\fold md.then (: (Markdown Block) md.empty)) diff --git a/stdlib/source/library/lux/ffi.jvm.lux b/stdlib/source/library/lux/ffi.jvm.lux index 52fdef075..d7f3c9544 100644 --- a/stdlib/source/library/lux/ffi.jvm.lux +++ b/stdlib/source/library/lux/ffi.jvm.lux @@ -1403,15 +1403,15 @@ (-> (List (Type Var)) Import_Member_Declaration (List (Type Var))) (case member (#ConstructorDecl [commons _]) - (list\compose class_tvars (get@ #import_member_tvars commons)) + (list\compose class_tvars (value@ #import_member_tvars commons)) (#MethodDecl [commons _]) - (case (get@ #import_member_kind commons) + (case (value@ #import_member_kind commons) #StaticIMK - (get@ #import_member_tvars commons) + (value@ #import_member_tvars commons) _ - (list\compose class_tvars (get@ #import_member_tvars commons))) + (list\compose class_tvars (value@ #import_member_tvars commons))) _ class_tvars)) @@ -1431,7 +1431,7 @@ .let [input_jvm_types (list\map product.right import_member_args) arg_types (list\map (: (-> [Bit (Type Value)] Code) (function (_ [maybe? arg]) - (let [arg_type (value_type (get@ #import_member_mode commons) arg)] + (let [arg_type (value_type (value@ #import_member_mode commons) arg)] (if maybe? (` (Maybe (~ arg_type))) arg_type)))) @@ -1449,7 +1449,7 @@ (dictionary.key? ..boxes unboxed)) return_term - (get@ #import_member_maybe? commons) + (value@ #import_member_maybe? commons) (` (??? (~ return_term))) ... else @@ -1468,7 +1468,7 @@ (-> Import_Member_Declaration Code Code) (case member (^or (#ConstructorDecl [commons _]) (#MethodDecl [commons _])) - (if (get@ <tag> commons) + (if (value@ <tag> commons) <term_trans> return_term) @@ -1599,16 +1599,16 @@ (#ConstructorDecl [commons _]) (do meta.monad [.let [classT (type.class full_name (list)) - def_name (code.identifier ["" (..import_name import_format method_prefix (get@ #import_member_alias commons))]) + def_name (code.identifier ["" (..import_name import_format method_prefix (value@ #import_member_alias commons))]) jvm_interop (|> [classT (` ("jvm member invoke constructor" [(~+ (list\map ..var$ class_tvars))] (~ (code.text full_name)) - [(~+ (list\map ..var$ (get@ #import_member_tvars commons)))] - (~+ (|> (jvm_invoke_inputs (get@ #import_member_mode commons) input_jvm_types arg_function_inputs) + [(~+ (list\map ..var$ (value@ #import_member_tvars commons)))] + (~+ (|> (jvm_invoke_inputs (value@ #import_member_mode commons) input_jvm_types arg_function_inputs) (list.zipped/2 input_jvm_types) (list\map ..decorate_input)))))] - (with_automatic_output_conversion (get@ #import_member_mode commons)) + (with_automatic_output_conversion (value@ #import_member_mode commons)) (with_return_maybe member true classT) (with_return_try member) (with_return_io member))]] @@ -1618,7 +1618,7 @@ (#MethodDecl [commons method]) (with_identifiers [g!obj] (do meta.monad - [.let [def_name (code.identifier ["" (..import_name import_format method_prefix (get@ #import_member_alias commons))]) + [.let [def_name (code.identifier ["" (..import_name import_format method_prefix (value@ #import_member_alias commons))]) (^slots [#import_member_kind]) commons (^slots [#import_method_name]) method [jvm_op object_ast] (: [Text (List Code)] @@ -1637,18 +1637,18 @@ ["jvm member invoke interface" (list g!obj)] ))) - method_return (get@ #import_method_return method) + method_return (value@ #import_method_return method) callC (: Code (` ((~ (code.text jvm_op)) [(~+ (list\map ..var$ class_tvars))] (~ (code.text full_name)) (~ (code.text import_method_name)) - [(~+ (list\map ..var$ (get@ #import_member_tvars commons)))] + [(~+ (list\map ..var$ (value@ #import_member_tvars commons)))] (~+ (|> object_ast (list\map ..un_quoted) (list.zipped/2 (list (type.class full_name (list)))) - (list\map (with_automatic_input_conversion (get@ #import_member_mode commons))))) - (~+ (|> (jvm_invoke_inputs (get@ #import_member_mode commons) input_jvm_types arg_function_inputs) + (list\map (with_automatic_input_conversion (value@ #import_member_mode commons))))) + (~+ (|> (jvm_invoke_inputs (value@ #import_member_mode commons) input_jvm_types arg_function_inputs) (list.zipped/2 input_jvm_types) (list\map ..decorate_input)))))) jvm_interop (: Code @@ -1656,7 +1656,7 @@ (#.Left method_return) (|> [method_return callC] - (with_automatic_output_conversion (get@ #import_member_mode commons)) + (with_automatic_output_conversion (value@ #import_member_mode commons)) (with_return_maybe member false method_return) (with_return_try member) (with_return_io member)) @@ -1809,7 +1809,7 @@ =members (|> bundles (list\map (function (_ [import_format members]) (list\map (|>> [import_format]) members))) - list.joined + list.together (monad.map ! (member_import$ class_type_vars kind declaration)))] (in (list& (class_import$ declaration) (list\join =members))))) @@ -1933,9 +1933,9 @@ _ <failure>)))) -(syntax: .public (array_length [array <code>.any]) +(syntax: .public (length [array <code>.any]) {#.doc (example "Gives the length of an array." - (array_length my_array))} + (length my_array))} (case array [_ (#.Identifier array_name)] (do meta.monad @@ -1967,12 +1967,12 @@ _ (with_identifiers [g!array] (in (list (` (let [(~ g!array) (~ array)] - (..array_length (~ g!array))))))))) + (..length (~ g!array))))))))) -(syntax: .public (array_read [idx <code>.any - array <code>.any]) +(syntax: .public (read! [idx <code>.any + array <code>.any]) {#.doc (example "Loads an element from an array." - (array_read 10 my_array))} + (read! 10 my_array))} (case array [_ (#.Identifier array_name)] (do meta.monad @@ -2006,13 +2006,13 @@ _ (with_identifiers [g!array] (in (list (` (let [(~ g!array) (~ array)] - (..array_read (~ idx) (~ g!array))))))))) + (..read! (~ idx) (~ g!array))))))))) -(syntax: .public (array_write [idx <code>.any - value <code>.any - array <code>.any]) +(syntax: .public (write! [idx <code>.any + value <code>.any + array <code>.any]) {#.doc (example "Stores an element into an array." - (array_write 10 my_object my_array))} + (write! 10 my_object my_array))} (case array [_ (#.Identifier array_name)] (do meta.monad @@ -2047,7 +2047,7 @@ _ (with_identifiers [g!array] (in (list (` (let [(~ g!array) (~ array)] - (..array_write (~ idx) (~ value) (~ g!array))))))))) + (..write! (~ idx) (~ value) (~ g!array))))))))) (syntax: .public (class_for [type (..type^ (list))]) {#.doc (example "Loads the class as a java.lang.Class object." diff --git a/stdlib/source/library/lux/ffi.old.lux b/stdlib/source/library/lux/ffi.old.lux index 29c286b23..9acf8e055 100644 --- a/stdlib/source/library/lux/ffi.old.lux +++ b/stdlib/source/library/lux/ffi.old.lux @@ -1098,7 +1098,7 @@ .let [arg_decls' (: (List Text) (list\map (|>> product.right (simple_class$ (list))) arg_decls))]] (in (`' ((~ (code.text (format "jvm invokespecial" - ":" (get@ #super_class_name super_class) + ":" (value@ #super_class_name super_class) ":" name ":" (text.interposed "," arg_decls')))) (~' _jvm_this) (~+ args)))))))] @@ -1368,15 +1368,15 @@ (-> (List Type_Parameter) Import_Member_Declaration (List Type_Parameter)) (case member (#ConstructorDecl [commons _]) - (list\compose class_tvars (get@ #import_member_tvars commons)) + (list\compose class_tvars (value@ #import_member_tvars commons)) (#MethodDecl [commons _]) - (case (get@ #import_member_kind commons) + (case (value@ #import_member_kind commons) #StaticIMK - (get@ #import_member_tvars commons) + (value@ #import_member_tvars commons) _ - (list\compose class_tvars (get@ #import_member_tvars commons))) + (list\compose class_tvars (value@ #import_member_tvars commons))) _ class_tvars)) @@ -1398,7 +1398,7 @@ import_member_args)) arg_types (list\map (: (-> [Bit GenericType] Code) (function (_ [maybe? arg]) - (let [arg_type (class_type (get@ #import_member_mode commons) type_params arg)] + (let [arg_type (class_type (value@ #import_member_mode commons) type_params arg)] (if maybe? (` (Maybe (~ arg_type))) arg_type)))) @@ -1412,7 +1412,7 @@ (-> Class_Declaration Import_Member_Declaration Code Code) (case member (^or (#ConstructorDecl [commons _]) (#MethodDecl [commons _])) - (if (get@ #import_member_maybe? commons) + (if (value@ #import_member_maybe? commons) (` (??? (~ return_term))) (let [g!temp (` ((~' ~') (~ (code.identifier ["" " Ω "]))))] (` (let [(~ g!temp) (~ return_term)] @@ -1420,8 +1420,8 @@ (~ g!temp)))) (~ g!temp) (panic! (~ (code.text (format "Cannot produce null references from method calls @ " - (get@ #class_name class) - "." (get@ #import_member_alias commons)))))))))) + (value@ #class_name class) + "." (value@ #import_member_alias commons)))))))))) _ return_term)) @@ -1431,7 +1431,7 @@ (-> Import_Member_Declaration Code Code) (case member (^or (#ConstructorDecl [commons _]) (#MethodDecl [commons _])) - (if (get@ <tag> commons) + (if (value@ <tag> commons) <term_trans> return_term) @@ -1527,10 +1527,10 @@ (#ConstructorDecl [commons _]) (do meta.monad - [.let [def_name (code.identifier ["" (..import_name import_format method_prefix (get@ #import_member_alias commons))]) + [.let [def_name (code.identifier ["" (..import_name import_format method_prefix (value@ #import_member_alias commons))]) jvm_extension (code.text (format "jvm new" ":" full_name ":" (text.interposed "," arg_classes))) jvm_interop (|> (` ((~ jvm_extension) - (~+ (jvm_extension_inputs (get@ #import_member_mode commons) arg_classes arg_function_inputs)))) + (~+ (jvm_extension_inputs (value@ #import_member_mode commons) arg_classes arg_function_inputs)))) (decorate_return_maybe class member) (decorate_return_try member) (decorate_return_io member))]] @@ -1540,7 +1540,7 @@ (#MethodDecl [commons method]) (with_identifiers [g!obj] (do meta.monad - [.let [def_name (code.identifier ["" (..import_name import_format method_prefix (get@ #import_member_alias commons))]) + [.let [def_name (code.identifier ["" (..import_name import_format method_prefix (value@ #import_member_alias commons))]) (^slots [#import_member_kind]) commons (^slots [#import_method_name]) method [jvm_op object_ast] (: [Text (List Code)] @@ -1560,10 +1560,10 @@ (list g!obj)] ))) jvm_extension (code.text (format "jvm " jvm_op ":" full_name ":" import_method_name ":" (text.interposed "," arg_classes))) - jvm_interop (|> [(simple_class$ (list) (get@ #import_method_return method)) + jvm_interop (|> [(simple_class$ (list) (value@ #import_method_return method)) (` ((~ jvm_extension) (~+ (list\map un_quote object_ast)) - (~+ (jvm_extension_inputs (get@ #import_member_mode commons) arg_classes arg_function_inputs))))] - (auto_convert_output (get@ #import_member_mode commons)) + (~+ (jvm_extension_inputs (value@ #import_member_mode commons) arg_classes arg_function_inputs))))] + (auto_convert_output (value@ #import_member_mode commons)) (decorate_return_maybe class member) (decorate_return_try member) (decorate_return_io member))]] @@ -1717,7 +1717,7 @@ =members (|> bundles (list\map (function (_ [import_format members]) (list\map (|>> [import_format]) members))) - list.joined + list.together (monad.map ! (member_import$ (product.right class_decl) kind class_decl)))] (in (list& (class_import$ class_decl) (list\join =members))))) @@ -1741,9 +1741,9 @@ _ (in (list (` ("jvm anewarray" (~ (code.text (generic_type$ type))) (~ size))))))) -(syntax: .public (array_length [array <code>.any]) +(syntax: .public (length [array <code>.any]) {#.doc (example "Gives the length of an array." - (array_length my_array))} + (length my_array))} (in (list (` ("jvm arraylength" (~ array)))))) (def: (type_class_name type) @@ -1768,10 +1768,10 @@ _ (meta.failure (format "Cannot convert to JvmType: " (type.format type)))))) -(syntax: .public (array_read [idx <code>.any - array <code>.any]) +(syntax: .public (read! [idx <code>.any + array <code>.any]) {#.doc (example "Loads an element from an array." - (array_read 10 my_array))} + (read! 10 my_array))} (case array [_ (#.Identifier array_name)] (do meta.monad @@ -1796,13 +1796,13 @@ _ (with_identifiers [g!array] (in (list (` (let [(~ g!array) (~ array)] - (..array_read (~ idx) (~ g!array))))))))) + (..read! (~ idx) (~ g!array))))))))) -(syntax: .public (array_write [idx <code>.any - value <code>.any - array <code>.any]) +(syntax: .public (write! [idx <code>.any + value <code>.any + array <code>.any]) {#.doc (example "Stores an element into an array." - (array_write 10 my_object my_array))} + (write! 10 my_object my_array))} (case array [_ (#.Identifier array_name)] (do meta.monad @@ -1827,7 +1827,7 @@ _ (with_identifiers [g!array] (in (list (` (let [(~ g!array) (~ array)] - (..array_write (~ idx) (~ value) (~ g!array))))))))) + (..write! (~ idx) (~ value) (~ g!array))))))))) (syntax: .public (class_for [type (..generic_type^ (list))]) {#.doc (example "Loads the class as a java.lang.Class object." diff --git a/stdlib/source/library/lux/locale/language.lux b/stdlib/source/library/lux/locale/language.lux index 1a7b52201..29ec7c190 100644 --- a/stdlib/source/library/lux/locale/language.lux +++ b/stdlib/source/library/lux/locale/language.lux @@ -21,7 +21,7 @@ (template [<name> <tag>] [(def: .public <name> (-> Language Text) - (|>> :representation (get@ <tag>)))] + (|>> :representation (value@ <tag>)))] [name #name] [code #code] diff --git a/stdlib/source/library/lux/locale/territory.lux b/stdlib/source/library/lux/locale/territory.lux index e0f569100..6309e1a86 100644 --- a/stdlib/source/library/lux/locale/territory.lux +++ b/stdlib/source/library/lux/locale/territory.lux @@ -24,7 +24,7 @@ [(def: .public <name> (-> Territory <type>) (|>> :representation - (get@ <field>)))] + (value@ <field>)))] [name #name Text] [short_code #short Text] @@ -309,6 +309,6 @@ (def: hash (|>> :representation - (get@ #long) + (value@ #long) (\ text.hash hash)))) ) diff --git a/stdlib/source/library/lux/macro/local.lux b/stdlib/source/library/lux/macro/local.lux index 8a10f5f26..8c518b855 100644 --- a/stdlib/source/library/lux/macro/local.lux +++ b/stdlib/source/library/lux/macro/local.lux @@ -34,11 +34,11 @@ (def: (with_module name body) (All [a] (-> Text (-> Module (Try [Module a])) (Meta a))) (function (_ compiler) - (case (|> compiler (get@ #.modules) (plist.value name)) + (case (|> compiler (value@ #.modules) (plist.value name)) (#.Some module) (case (body module) (#try.Success [module' output]) - (#try.Success [(update@ #.modules (plist.has name module') compiler) + (#try.Success [(revised@ #.modules (plist.has name module') compiler) output]) (#try.Failure error) @@ -56,9 +56,9 @@ (plist.has definition_name definition))]] (..with_module module_name (function (_ module) - (case (|> module (get@ #.definitions) (plist.value definition_name)) + (case (|> module (value@ #.definitions) (plist.value definition_name)) #.None - (#try.Success [(update@ #.definitions add_macro! module) + (#try.Success [(revised@ #.definitions add_macro! module) []]) (#.Some _) @@ -72,9 +72,9 @@ (plist.lacks definition_name))]] (..with_module module_name (function (_ module) - (case (|> module (get@ #.definitions) (plist.value definition_name)) + (case (|> module (value@ #.definitions) (plist.value definition_name)) (#.Some _) - (#try.Success [(update@ #.definitions lacks_macro! module) + (#try.Success [(revised@ #.definitions lacks_macro! module) []]) #.None @@ -88,7 +88,7 @@ [_ (monad.map ! ..pop_one macros) _ (..pop_one self) compiler meta.compiler_state] - (in (case (get@ #.expected compiler) + (in (case (value@ #.expected compiler) (#.Some _) (list (' [])) diff --git a/stdlib/source/library/lux/macro/syntax/annotations.lux b/stdlib/source/library/lux/macro/syntax/annotations.lux index 1db17d9b5..5e23ea9d8 100644 --- a/stdlib/source/library/lux/macro/syntax/annotations.lux +++ b/stdlib/source/library/lux/macro/syntax/annotations.lux @@ -31,7 +31,7 @@ (def: .public format (-> Annotations Code) - (let [entry (product.apply code.tag function.identity)] + (let [entry (product.then code.tag function.identity)] (|>> (list\map entry) code.record))) diff --git a/stdlib/source/library/lux/macro/syntax/declaration.lux b/stdlib/source/library/lux/macro/syntax/declaration.lux index c85e74822..1a529d3db 100644 --- a/stdlib/source/library/lux/macro/syntax/declaration.lux +++ b/stdlib/source/library/lux/macro/syntax/declaration.lux @@ -39,8 +39,8 @@ (def: .public (format value) (-> Declaration Code) - (let [g!name (code.local_identifier (get@ #name value))] - (case (get@ #arguments value) + (let [g!name (code.local_identifier (value@ #name value))] + (case (value@ #arguments value) #.End g!name diff --git a/stdlib/source/library/lux/macro/syntax/definition.lux b/stdlib/source/library/lux/macro/syntax/definition.lux index 7ebf281d4..14e907870 100644 --- a/stdlib/source/library/lux/macro/syntax/definition.lux +++ b/stdlib/source/library/lux/macro/syntax/definition.lux @@ -66,9 +66,9 @@ (def: dummy Code - (` {#.module (~ (code.text (get@ #.module location.dummy))) - #.line (~ (code.nat (get@ #.line location.dummy))) - #.column (~ (code.nat (get@ #.column location.dummy)))})) + (` {#.module (~ (code.text (value@ #.module location.dummy))) + #.line (~ (code.nat (value@ #.line location.dummy))) + #.column (~ (code.nat (value@ #.column location.dummy)))})) (def: .public (format (^slots [#name #value #anns #export?])) (-> Definition Code) @@ -133,7 +133,7 @@ (-> Lux (Parser Definition)) (do <>.monad [definition (..parser compiler) - _ (case (get@ #value definition) + _ (case (value@ #value definition) (#.Left _) (in []) diff --git a/stdlib/source/library/lux/macro/syntax/input.lux b/stdlib/source/library/lux/macro/syntax/input.lux index 6754185af..77623fbd7 100644 --- a/stdlib/source/library/lux/macro/syntax/input.lux +++ b/stdlib/source/library/lux/macro/syntax/input.lux @@ -26,8 +26,8 @@ (def: .public (format value) (-> Input Code) (code.record - (list [(get@ #binding value) - (get@ #type value)]))) + (list [(value@ #binding value) + (value@ #type value)]))) (def: .public parser {#.doc "Parser for the common typed-argument syntax used by many macros."} diff --git a/stdlib/source/library/lux/macro/template.lux b/stdlib/source/library/lux/macro/template.lux index 8de4f2501..d378f9409 100644 --- a/stdlib/source/library/lux/macro/template.lux +++ b/stdlib/source/library/lux/macro/template.lux @@ -44,7 +44,7 @@ (do {! meta.monad} [g!locals (|> locals (list\map //.identifier) - (monad.seq !))] + (monad.all !))] (in (list (` (.with_expansions [(~+ (|> (list.zipped/2 locals g!locals) (list\map (function (_ [name identifier]) (list (code.local_identifier name) (as_is identifier)))) @@ -196,14 +196,14 @@ [here_name meta.current_module_name expression? (: (Meta Bit) (function (_ lux) - (#try.Success [lux (case (get@ #.expected lux) + (#try.Success [lux (case (value@ #.expected lux) #.None false (#.Some _) true)]))) g!pop (local.push (list\map (function (_ local) - [[here_name (get@ #name local)] + [[here_name (value@ #name local)] (..macro local)]) locals))] (if expression? diff --git a/stdlib/source/library/lux/math.lux b/stdlib/source/library/lux/math.lux index 7f19f1a85..e088df673 100644 --- a/stdlib/source/library/lux/math.lux +++ b/stdlib/source/library/lux/math.lux @@ -331,7 +331,7 @@ n n] (if (n.<= 1 n) acc - (recur (n.* n acc) (dec n))))) + (recur (n.* n acc) (-- n))))) (def: .public (hypotenuse catA catB) (-> Frac Frac Frac) diff --git a/stdlib/source/library/lux/math/number/complex.lux b/stdlib/source/library/lux/math/number/complex.lux index 1615bf633..d26544c0b 100644 --- a/stdlib/source/library/lux/math/number/complex.lux +++ b/stdlib/source/library/lux/math/number/complex.lux @@ -50,23 +50,23 @@ (..complex +0.0 +0.0)) (def: .public (not_a_number? complex) - (or (f.not_a_number? (get@ #real complex)) - (f.not_a_number? (get@ #imaginary complex)))) + (or (f.not_a_number? (value@ #real complex)) + (f.not_a_number? (value@ #imaginary complex)))) (def: .public (= param input) (-> Complex Complex Bit) - (and (f.= (get@ #real param) - (get@ #real input)) - (f.= (get@ #imaginary param) - (get@ #imaginary input)))) + (and (f.= (value@ #real param) + (value@ #real input)) + (f.= (value@ #imaginary param) + (value@ #imaginary input)))) (template [<name> <op>] [(def: .public (<name> param input) (-> Complex Complex Complex) - {#real (<op> (get@ #real param) - (get@ #real input)) - #imaginary (<op> (get@ #imaginary param) - (get@ #imaginary input))})] + {#real (<op> (value@ #real param) + (value@ #real input)) + #imaginary (<op> (value@ #imaginary param) + (value@ #imaginary input))})] [+ f.+] [- f.-] @@ -80,8 +80,8 @@ (template [<name> <transform>] [(def: .public <name> (-> Complex Complex) - (|>> (update@ #real <transform>) - (update@ #imaginary <transform>)))] + (|>> (revised@ #real <transform>) + (revised@ #imaginary <transform>)))] [opposite f.opposite] [signum f.signum] @@ -89,25 +89,25 @@ (def: .public conjugate (-> Complex Complex) - (update@ #imaginary f.opposite)) + (revised@ #imaginary f.opposite)) (def: .public (*' param input) (-> Frac Complex Complex) {#real (f.* param - (get@ #real input)) + (value@ #real input)) #imaginary (f.* param - (get@ #imaginary input))}) + (value@ #imaginary input))}) (def: .public (* param input) (-> Complex Complex Complex) - {#real (f.- (f.* (get@ #imaginary param) - (get@ #imaginary input)) - (f.* (get@ #real param) - (get@ #real input))) - #imaginary (f.+ (f.* (get@ #real param) - (get@ #imaginary input)) - (f.* (get@ #imaginary param) - (get@ #real input)))}) + {#real (f.- (f.* (value@ #imaginary param) + (value@ #imaginary input)) + (f.* (value@ #real param) + (value@ #real input))) + #imaginary (f.+ (f.* (value@ #real param) + (value@ #imaginary input)) + (f.* (value@ #imaginary param) + (value@ #real input)))}) (def: .public (/ param input) (-> Complex Complex Complex) @@ -116,12 +116,12 @@ (f.abs real)) (let [quot (f./ imaginary real) denom (|> real (f.* quot) (f.+ imaginary))] - {#real (|> (get@ #real input) (f.* quot) (f.+ (get@ #imaginary input)) (f./ denom)) - #imaginary (|> (get@ #imaginary input) (f.* quot) (f.- (get@ #real input)) (f./ denom))}) + {#real (|> (value@ #real input) (f.* quot) (f.+ (value@ #imaginary input)) (f./ denom)) + #imaginary (|> (value@ #imaginary input) (f.* quot) (f.- (value@ #real input)) (f./ denom))}) (let [quot (f./ real imaginary) denom (|> imaginary (f.* quot) (f.+ real))] - {#real (|> (get@ #imaginary input) (f.* quot) (f.+ (get@ #real input)) (f./ denom)) - #imaginary (|> (get@ #imaginary input) (f.- (f.* quot (get@ #real input))) (f./ denom))})))) + {#real (|> (value@ #imaginary input) (f.* quot) (f.+ (value@ #real input)) (f./ denom)) + #imaginary (|> (value@ #imaginary input) (f.- (f.* quot (value@ #real input))) (f./ denom))})))) (def: .public (/' param subject) (-> Frac Complex Complex) @@ -133,8 +133,8 @@ (-> Complex Complex Complex) (let [scaled (/ param input) quotient (|> scaled - (update@ #real math.floor) - (update@ #imaginary math.floor))] + (revised@ #real math.floor) + (revised@ #imaginary math.floor))] (- (* quotient param) input))) @@ -311,8 +311,8 @@ (def: .public (approximately? margin_of_error standard value) (-> Frac Complex Complex Bit) (and (f.approximately? margin_of_error - (get@ #..real standard) - (get@ #..real value)) + (value@ #..real standard) + (value@ #..real value)) (f.approximately? margin_of_error - (get@ #..imaginary standard) - (get@ #..imaginary value)))) + (value@ #..imaginary standard) + (value@ #..imaginary value)))) diff --git a/stdlib/source/library/lux/math/number/frac.lux b/stdlib/source/library/lux/math/number/frac.lux index 9e49975f8..1d92184b8 100644 --- a/stdlib/source/library/lux/math/number/frac.lux +++ b/stdlib/source/library/lux/math/number/frac.lux @@ -288,7 +288,7 @@ exponent_bits (|> (if (..< +0.0 min_gap) (|> (..int exponent) (//int.- (..int min_gap)) - dec) + --) (..int exponent)) (//int.+ (.int ..double_bias)) (//i64.and ..exponent_mask)) @@ -302,7 +302,7 @@ (template [<getter> <size> <offset>] [(def: <getter> (-> (I64 Any) I64) - (let [mask (|> 1 (//i64.left_shifted <size>) dec (//i64.left_shifted <offset>))] + (let [mask (|> 1 (//i64.left_shifted <size>) -- (//i64.left_shifted <offset>))] (|>> (//i64.and mask) (//i64.right_shifted <offset>) .i64)))] [mantissa ..mantissa_size 0] @@ -400,7 +400,7 @@ [whole decimal] (case ("lux text index" 0 "." mantissa) (#.Some split_index) (do ! - [.let [after_offset (inc split_index) + [.let [after_offset (++ split_index) after_length (//nat.- after_offset ("lux text size" mantissa))] decimal (|> mantissa ("lux text clip" after_offset after_length) @@ -410,7 +410,7 @@ #.None (#try.Failure ("lux text concat" <error> representation))) - .let [whole ("lux text clip" 1 (dec ("lux text size" whole)) whole)] + .let [whole ("lux text clip" 1 (-- ("lux text size" whole)) whole)] mantissa (\ <nat> decode (case decimal 0 whole _ ("lux text concat" whole (\ <nat> encode decimal)))) diff --git a/stdlib/source/library/lux/math/number/i64.lux b/stdlib/source/library/lux/math/number/i64.lux index fd0c5545b..42c08e00a 100644 --- a/stdlib/source/library/lux/math/number/i64.lux +++ b/stdlib/source/library/lux/math/number/i64.lux @@ -48,12 +48,12 @@ (def: .public sign {#.doc (example "A mask for the sign bit of ints.")} Mask - (..bit (dec ..width))) + (..bit (-- ..width))) (def: .public not {#.doc "Bitwise negation."} (All [s] (-> (I64 s) (I64 s))) - (..xor (.i64 (dec 0)))) + (..xor (.i64 (-- 0)))) (def: .public false Mask @@ -70,7 +70,7 @@ 0 ..false bits (case (n.% ..width bits) 0 ..true - bits (|> 1 .i64 (..left_shifted (n.% ..width bits)) .dec)))) + bits (|> 1 .i64 (..left_shifted (n.% ..width bits)) .--)))) (def: (with_shift shift value) (-> Nat Nat Nat) @@ -161,7 +161,7 @@ (loop [iterations 1 output char] (if (n.< times iterations) - (recur (inc iterations) + (recur (++ iterations) ("lux text concat" char output)) output)))) pattern (repetitions (n./ (n.+ size size) ..width) @@ -206,8 +206,8 @@ (if (.and (n.> 0 width) (n.< ..width width)) (let [sign_shift (n.- width ..width) - sign (..bit (dec width)) - mantissa (..mask (dec width)) + sign (..bit (-- width)) + mantissa (..mask (-- width)) co_mantissa (..xor (.i64 -1) mantissa)] (#.Some (: Sub (implementation diff --git a/stdlib/source/library/lux/math/number/int.lux b/stdlib/source/library/lux/math/number/int.lux index 88ba6bba1..d5546a4a5 100644 --- a/stdlib/source/library/lux/math/number/int.lux +++ b/stdlib/source/library/lux/math/number/int.lux @@ -186,8 +186,8 @@ (Enum Int) (def: &order ..order) - (def: succ inc) - (def: pred dec)) + (def: succ ++) + (def: pred --)) ... TODO: Find out why the numeric literals fail during JS compilation. (implementation: .public interval @@ -198,7 +198,7 @@ ... +9,223,372,036,854,775,807 (let [half (//i64.left_shifted 62 +1)] (+ half - (dec half)))) + (-- half)))) (def: bottom ... -9,223,372,036,854,775,808 (//i64.left_shifted 63 +1))) @@ -225,7 +225,7 @@ (def: (encode value) (if (..< +0 value) - (|> value inc ..opposite .nat inc (\ <codec> encode) ("lux text concat" ..-sign)) + (|> value ++ ..opposite .nat ++ (\ <codec> encode) ("lux text concat" ..-sign)) (|> value .nat (\ <codec> encode) ("lux text concat" ..+sign)))) (def: (decode repr) @@ -234,15 +234,15 @@ (case ("lux text clip" 0 1 repr) (^ (static ..+sign)) (|> repr - ("lux text clip" 1 (dec input_size)) + ("lux text clip" 1 (-- input_size)) (\ <codec> decode) (\ try.functor map .int)) (^ (static ..-sign)) (|> repr - ("lux text clip" 1 (dec input_size)) + ("lux text clip" 1 (-- input_size)) (\ <codec> decode) - (\ try.functor map (|>> dec .int ..opposite dec))) + (\ try.functor map (|>> -- .int ..opposite --))) _ (#try.Failure <error>)) diff --git a/stdlib/source/library/lux/math/number/nat.lux b/stdlib/source/library/lux/math/number/nat.lux index bd6ff389c..c72289e0d 100644 --- a/stdlib/source/library/lux/math/number/nat.lux +++ b/stdlib/source/library/lux/math/number/nat.lux @@ -170,14 +170,14 @@ (Enum Nat) (def: &order ..order) - (def: succ inc) - (def: pred dec)) + (def: succ ++) + (def: pred --)) (implementation: .public interval (Interval Nat) (def: &enum ..enum) - (def: top (dec 0)) + (def: top (-- 0)) (def: bottom 0)) (template [<name> <compose> <identity>] @@ -303,7 +303,7 @@ (Codec Text Nat) (def: encode - (let [mask (|> 1 ("lux i64 left-shift" <shift>) dec)] + (let [mask (|> 1 ("lux i64 left-shift" <shift>) --)] (function (_ value) (loop [input value output ""] @@ -325,7 +325,7 @@ (if (..< input_size idx) (case (<to_value> ("lux text char" idx repr)) (#.Some digit_value) - (recur (inc idx) + (recur (++ idx) (|> output ("lux i64 left-shift" <shift>) ("lux i64 or" digit_value))) @@ -367,7 +367,7 @@ <failure> (#.Some digit_value) - (recur (inc idx) + (recur (++ idx) (|> output (..* 10) (..+ digit_value)))) (#try.Success output))) <failure>))))) diff --git a/stdlib/source/library/lux/math/number/ratio.lux b/stdlib/source/library/lux/math/number/ratio.lux index cfb3eca00..5d5962b47 100644 --- a/stdlib/source/library/lux/math/number/ratio.lux +++ b/stdlib/source/library/lux/math/number/ratio.lux @@ -30,8 +30,8 @@ (def: .public (nat value) (-> Ratio (Maybe Nat)) - (case (get@ #denominator value) - 1 (#.Some (get@ #numerator value)) + (case (value@ #denominator value) + 1 (#.Some (value@ #numerator value)) _ #.None)) (def: (normal (^slots [#numerator #denominator])) @@ -51,10 +51,10 @@ (def: .public (= parameter subject) (-> Ratio Ratio Bit) - (and (n.= (get@ #numerator parameter) - (get@ #numerator subject)) - (n.= (get@ #denominator parameter) - (get@ #denominator subject)))) + (and (n.= (value@ #numerator parameter) + (value@ #numerator subject)) + (n.= (value@ #denominator parameter) + (value@ #denominator subject)))) (implementation: .public equivalence (Equivalence Ratio) @@ -63,10 +63,10 @@ (def: (equalized parameter subject) (-> Ratio Ratio [Nat Nat]) - [(n.* (get@ #denominator subject) - (get@ #numerator parameter)) - (n.* (get@ #denominator parameter) - (get@ #numerator subject))]) + [(n.* (value@ #denominator subject) + (value@ #numerator parameter)) + (n.* (value@ #denominator parameter) + (value@ #numerator subject))]) (def: .public (< parameter subject) (-> Ratio Ratio Bit) @@ -97,22 +97,22 @@ (-> Ratio Ratio Ratio) (let [[parameter' subject'] (..equalized parameter subject)] (normal [(n.+ parameter' subject') - (n.* (get@ #denominator parameter) - (get@ #denominator subject))]))) + (n.* (value@ #denominator parameter) + (value@ #denominator subject))]))) (def: .public (- parameter subject) (-> Ratio Ratio Ratio) (let [[parameter' subject'] (..equalized parameter subject)] (normal [(n.- parameter' subject') - (n.* (get@ #denominator parameter) - (get@ #denominator subject))]))) + (n.* (value@ #denominator parameter) + (value@ #denominator subject))]))) (def: .public (* parameter subject) (-> Ratio Ratio Ratio) - (normal [(n.* (get@ #numerator parameter) - (get@ #numerator subject)) - (n.* (get@ #denominator parameter) - (get@ #denominator subject))])) + (normal [(n.* (value@ #numerator parameter) + (value@ #numerator subject)) + (n.* (value@ #denominator parameter) + (value@ #denominator subject))])) (def: .public (/ parameter subject) (-> Ratio Ratio Ratio) @@ -123,7 +123,7 @@ (-> Ratio Ratio Ratio) (let [[parameter' subject'] (..equalized parameter subject) quot (n./ parameter' subject')] - (..- (update@ #numerator (n.* quot) parameter) + (..- (revised@ #numerator (n.* quot) parameter) subject))) (def: .public (reciprocal (^slots [#numerator #denominator])) diff --git a/stdlib/source/library/lux/math/number/rev.lux b/stdlib/source/library/lux/math/number/rev.lux index 4eea3ecf7..3fc60202c 100644 --- a/stdlib/source/library/lux/math/number/rev.lux +++ b/stdlib/source/library/lux/math/number/rev.lux @@ -119,7 +119,7 @@ ("lux i64 +" top)))) (def: even_one (//i64.right_rotated 1 1)) -(def: odd_one (dec 0)) +(def: odd_one (-- 0)) (def: (even_reciprocal numerator) (-> Nat Nat) @@ -205,8 +205,8 @@ (Enum Rev) (def: &order ..order) - (def: succ inc) - (def: pred dec)) + (def: succ ++) + (def: pred --)) (implementation: .public interval (Interval Rev) @@ -229,7 +229,7 @@ (def: (decimals input) (-> Text Text) - ("lux text clip" 1 (dec ("lux text size" input)) input)) + ("lux text clip" 1 (-- ("lux text size" input)) input)) (template [<struct> <codec> <char_bit_size> <error>] [(with_expansions [<error_output> (as_is (#try.Failure ("lux text concat" <error> repr)))] @@ -248,7 +248,7 @@ output (: Text "")] (if (//nat.= 0 zeroes_left) output - (recur (dec zeroes_left) + (recur (-- zeroes_left) ("lux text concat" "0" output)))))] (|> raw_output ("lux text concat" zero_padding) @@ -311,7 +311,7 @@ (let [raw (|> (..digit idx output) (//nat.* 5) (//nat.+ carry))] - (recur (dec idx) + (recur (-- idx) (//nat./ 10 raw) (digits\put! idx (//nat.% 10 raw) output))) output))) @@ -322,21 +322,21 @@ output (|> (..digits []) (digits\put! power 1))] (if (//int.>= +0 (.int times)) - (recur (dec times) + (recur (-- times) (digits\times_5! power output)) output))) (def: (format digits) (-> Digits Text) - (loop [idx (dec //i64.width) + (loop [idx (-- //i64.width) all_zeroes? true output ""] (if (//int.>= +0 (.int idx)) (let [digit (..digit idx digits)] (if (and (//nat.= 0 digit) all_zeroes?) - (recur (dec idx) true output) - (recur (dec idx) + (recur (-- idx) true output) + (recur (-- idx) false ("lux text concat" (\ //nat.decimal encode digit) @@ -347,7 +347,7 @@ (def: (digits\+! param subject) (-> Digits Digits Digits) - (loop [idx (dec //i64.width) + (loop [idx (-- //i64.width) carry 0 output (..digits [])] (if (//int.>= +0 (.int idx)) @@ -355,7 +355,7 @@ carry (..digit idx param) (..digit idx subject))] - (recur (dec idx) + (recur (-- idx) (//nat./ 10 raw) (digits\put! idx (//nat.% 10 raw) output))) output))) @@ -372,7 +372,7 @@ #.None (#.Some digit) - (recur (inc idx) + (recur (++ idx) (digits\put! idx digit output))) (#.Some output))) #.None))) @@ -384,7 +384,7 @@ (let [pd (..digit idx param) sd (..digit idx subject)] (if (//nat.= pd sd) - (recur (inc idx)) + (recur (++ idx)) (//nat.< pd sd)))))) (def: (digits\-!' idx param subject) @@ -397,14 +397,14 @@ (//nat.- param))] (|> subject (digits\put! idx diff) - (digits\-!' (dec idx) 1)))))) + (digits\-!' (-- idx) 1)))))) (def: (digits\-! param subject) (-> Digits Digits Digits) - (loop [idx (dec //i64.width) + (loop [idx (-- //i64.width) output subject] (if (//int.>= +0 (.int idx)) - (recur (dec idx) + (recur (-- idx) (digits\-!' idx (..digit idx param) output)) output))) @@ -417,16 +417,16 @@ ".0" input - (let [last_idx (dec //i64.width)] + (let [last_idx (-- //i64.width)] (loop [idx last_idx digits (..digits [])] (if (//int.>= +0 (.int idx)) (if (//i64.one? idx input) (let [digits' (digits\+! (power_digits (//nat.- idx last_idx)) digits)] - (recur (dec idx) + (recur (-- idx) digits')) - (recur (dec idx) + (recur (-- idx) digits)) ("lux text concat" "." (..format digits)) ))))) @@ -438,7 +438,7 @@ _ false) - within_limits? (//nat.<= (inc //i64.width) + within_limits? (//nat.<= (++ //i64.width) ("lux text size" input))] (if (and dotted? within_limits?) (case (|> input ..decimals ..text_digits) @@ -450,10 +450,10 @@ (let [power (power_digits idx)] (if (digits\< power digits) ... Skip power - (recur digits (inc idx) output) + (recur digits (++ idx) output) (recur (digits\-! power digits) - (inc idx) - (//i64.one (//nat.- idx (dec //i64.width)) output)))) + (++ idx) + (//i64.one (//nat.- idx (-- //i64.width)) output)))) (#try.Success (.rev output)))) #.None diff --git a/stdlib/source/library/lux/math/random.lux b/stdlib/source/library/lux/math/random.lux index bb66000be..6b61b5159 100644 --- a/stdlib/source/library/lux/math/random.lux +++ b/stdlib/source/library/lux/math/random.lux @@ -145,7 +145,7 @@ {#.doc (example "A number in the interval [0.0,1.0].")} (Random Frac) (let [mantissa_range (.int (i64.left_shifted 53 1)) - mantissa_max (i.frac (dec mantissa_range))] + mantissa_max (i.frac (-- mantissa_range))] (\ ..monad map (|>> (i.% mantissa_range) i.frac @@ -169,7 +169,7 @@ (\ ..monad in "") (do ..monad [x char_gen - xs (text char_gen (dec size))] + xs (text char_gen (-- size))] (in (text\compose (text.of_char x) xs))))) (template [<name> <set>] @@ -251,12 +251,12 @@ (if (n.> 0 size) (do ..monad [x value_gen - xs (<name> (dec size) value_gen)] + xs (<name> (-- size) value_gen)] (in (<plus> x xs))) (\ ..monad in <zero>)))] [list List (.list) #.Item] - [row Row row.empty row.add] + [row Row row.empty row.suffix] ) (template [<name> <type> <ctor>] @@ -275,7 +275,7 @@ (All [a] (-> (Hash a) Nat (Random a) (Random (Set a)))) (if (n.> 0 size) (do {! ..monad} - [xs (set hash (dec size) value_gen)] + [xs (set hash (-- size) value_gen)] (loop [_ []] (do ! [x value_gen @@ -289,7 +289,7 @@ (All [k v] (-> (Hash k) Nat (Random k) (Random v) (Random (Dictionary k v)))) (if (n.> 0 size) (do {! ..monad} - [kv (dictionary hash (dec size) key_gen value_gen)] + [kv (dictionary hash (-- size) key_gen value_gen)] (loop [_ []] (do ! [k key_gen diff --git a/stdlib/source/library/lux/meta.lux b/stdlib/source/library/lux/meta.lux index b415adb91..7b6e893d3 100644 --- a/stdlib/source/library/lux/meta.lux +++ b/stdlib/source/library/lux/meta.lux @@ -118,13 +118,13 @@ (All [a] (-> Text (Meta a))) (function (_ state) - (#try.Failure (location.with (get@ #.location state) error)))) + (#try.Failure (location.with (value@ #.location state) error)))) (def: .public (module name) {#.doc (example "Looks-up a module with the given name.")} (-> Text (Meta Module)) (function (_ lux) - (case (plist.value name (get@ #.modules lux)) + (case (plist.value name (value@ #.modules lux)) (#.Some module) (#try.Success [lux module]) @@ -135,7 +135,7 @@ {#.doc (example "The name of the module currently being compiled, if any.")} (Meta Text) (function (_ lux) - (case (get@ #.current_module lux) + (case (value@ #.current_module lux) (#.Some current_module) (#try.Success [lux current_module]) @@ -179,7 +179,7 @@ [$module (plist.value module modules) definition (: (Maybe Global) (|> (: Module $module) - (get@ #.definitions) + (value@ #.definitions) (plist.value name)))] (case definition (#.Alias [r_module r_name]) @@ -202,7 +202,7 @@ #.None (#try.Success [_ this_module]) - (macro' (get@ #.modules lux) this_module module name))] + (macro' (value@ #.modules lux) this_module module name))] (#try.Success [lux macro])))))) (def: .public seed @@ -211,13 +211,13 @@ "This number can be used for generating data 'randomly' during compilation.")} (Meta Nat) (function (_ lux) - (#try.Success [(update@ #.seed inc lux) - (get@ #.seed lux)]))) + (#try.Success [(revised@ #.seed ++ lux) + (value@ #.seed lux)]))) (def: .public (module_exists? module) (-> Text (Meta Bit)) (function (_ lux) - (#try.Success [lux (case (plist.value module (get@ #.modules lux)) + (#try.Success [lux (case (plist.value module (value@ #.modules lux)) (#.Some _) #1 @@ -248,7 +248,7 @@ (#.Var var) (function (_ lux) (case (|> lux - (get@ [#.type_context #.var_bindings]) + (value@ [#.type_context #.var_bindings]) (type_variable var)) (^or #.None (#.Some (#.Var _))) (#try.Success [lux type]) @@ -268,15 +268,15 @@ (case (do maybe.monad [scope (list.example (function (_ env) (or (list.any? test (: (List [Text [Type Any]]) - (get@ [#.locals #.mappings] env))) + (value@ [#.locals #.mappings] env))) (list.any? test (: (List [Text [Type Any]]) - (get@ [#.captured #.mappings] env))))) - (get@ #.scopes lux)) + (value@ [#.captured #.mappings] env))))) + (value@ #.scopes lux)) [_ [type _]] (on_either (list.example test) (: (List [Text [Type Any]]) - (get@ [#.locals #.mappings] scope)) + (value@ [#.locals #.mappings] scope)) (: (List [Text [Type Any]]) - (get@ [#.captured #.mappings] scope)))] + (value@ [#.captured #.mappings] scope)))] (in type)) (#.Some var_type) ((clean_type var_type) lux) @@ -310,28 +310,28 @@ (case (: (Maybe Global) (do maybe.monad [(^slots [#.definitions]) (|> lux - (get@ #.modules) + (value@ #.modules) (plist.value normal_module))] (plist.value normal_short definitions))) (#.Some definition) (#try.Success [lux definition]) _ - (let [current_module (|> lux (get@ #.current_module) (maybe.else "???")) + (let [current_module (|> lux (value@ #.current_module) (maybe.else "???")) all_known_modules (|> lux - (get@ #.modules) + (value@ #.modules) (list\map product.left) ..module_listing)] (#try.Failure ($_ text\compose "Unknown definition: " (name\encode name) text.new_line " Current module: " current_module text.new_line - (case (plist.value current_module (get@ #.modules lux)) + (case (plist.value current_module (value@ #.modules lux)) (#.Some this_module) (let [candidates (|> lux - (get@ #.modules) + (value@ #.modules) (list\map (function (_ [module_name module]) (|> module - (get@ #.definitions) + (value@ #.definitions) (list.all (function (_ [def_name global]) (case global (#.Definition [exported? _ _ _]) @@ -342,14 +342,14 @@ (#.Alias _) #.None)))))) - list.joined + list.together (list.sorted text\<) (text.interposed ..listing_separator)) imports (|> this_module - (get@ #.imports) + (value@ #.imports) ..module_listing) aliases (|> this_module - (get@ #.module_aliases) + (value@ #.module_aliases) (list\map (function (_ [alias real]) ($_ text\compose alias " => " real))) (list.sorted text\<) (text.interposed ..listing_separator))] @@ -425,12 +425,12 @@ {#.doc "The entire list of globals in a module (including the non-exported/private ones)."} (-> Text (Meta (List [Text Global]))) (function (_ lux) - (case (plist.value module (get@ #.modules lux)) + (case (plist.value module (value@ #.modules lux)) #.None (#try.Failure ($_ text\compose "Unknown module: " module)) (#.Some module) - (#try.Success [lux (get@ #.definitions module)])))) + (#try.Success [lux (value@ #.definitions module)])))) (def: .public (definitions module) {#.doc "The entire list of definitions in a module (including the non-exported/private ones)."} @@ -461,7 +461,7 @@ (Meta (List [Text Module])) (function (_ lux) (|> lux - (get@ #.modules) + (value@ #.modules) [lux] #try.Success))) @@ -471,7 +471,7 @@ (do ..monad [.let [[module name] type_name] module (..module module)] - (case (plist.value name (get@ #.types module)) + (case (plist.value name (value@ #.types module)) (#.Some [tags _]) (in (#.Some tags)) @@ -482,13 +482,13 @@ {#.doc "The location of the current expression being analyzed."} (Meta Location) (function (_ lux) - (#try.Success [lux (get@ #.location lux)]))) + (#try.Success [lux (value@ #.location lux)]))) (def: .public expected_type {#.doc "The expected type of the current expression being analyzed."} (Meta Type) (function (_ lux) - (case (get@ #.expected lux) + (case (value@ #.expected lux) (#.Some type) (#try.Success [lux type]) @@ -512,7 +512,7 @@ {#.doc (example "Checks if the given module has been imported by the current module.")} (-> Text (Meta Bit)) (\ ..functor map - (|>> (get@ #.imports) (list.any? (text\= import))) + (|>> (value@ #.imports) (list.any? (text\= import))) ..current_module)) (def: .public (tag tag_name) @@ -523,7 +523,7 @@ =module (..module module) this_module_name ..current_module_name imported! (..imported? module)] - (case (plist.value name (get@ #.tags =module)) + (case (plist.value name (value@ #.tags =module)) (#.Some [idx tag_list exported? type]) (if (or (text\= this_module_name module) (and imported! exported?)) @@ -534,9 +534,9 @@ (..failure ($_ text\compose "Unknown tag: " (name\encode tag_name) text.new_line " Known tags: " (|> =module - (get@ #.tags) + (value@ #.tags) (list\map (|>> product.left [module] name\encode (text.prefix text.new_line))) - text.joined) + text.together) ))))) (def: .public (tag_lists module) @@ -545,7 +545,7 @@ (do ..monad [=module (..module module) this_module_name ..current_module_name] - (in (|> (get@ #.types =module) + (in (|> (value@ #.types =module) (list.only (function (_ [type_name [tag_list exported? type]]) (or exported? (text\= this_module_name module)))) @@ -556,13 +556,13 @@ {#.doc "All the local variables currently in scope, separated in different scopes."} (Meta (List (List [Text Type]))) (function (_ lux) - (case (list.inits (get@ #.scopes lux)) + (case (list.inits (value@ #.scopes lux)) #.None (#try.Failure "No local environment") (#.Some scopes) (#try.Success [lux - (list\map (|>> (get@ [#.locals #.mappings]) + (list\map (|>> (value@ [#.locals #.mappings]) (list\map (function (_ [name [type _]]) [name type]))) scopes)])))) @@ -589,7 +589,7 @@ {#.doc (example "The current type-checking context.")} (Meta Type_Context) (function (_ lux) - (#try.Success [lux (get@ #.type_context lux)]))) + (#try.Success [lux (value@ #.type_context lux)]))) (def: .public (lifted result) (All [a] (-> (Try a) (Meta a))) diff --git a/stdlib/source/library/lux/meta/location.lux b/stdlib/source/library/lux/meta/location.lux index 0c089da36..24511eb26 100644 --- a/stdlib/source/library/lux/meta/location.lux +++ b/stdlib/source/library/lux/meta/location.lux @@ -8,9 +8,9 @@ (Equivalence Location) (def: (= reference subject) - (and ("lux text =" (get@ #.module reference) (get@ #.module subject)) - ("lux i64 =" (get@ #.line reference) (get@ #.line subject)) - ("lux i64 =" (get@ #.column reference) (get@ #.column subject))))) + (and ("lux text =" (value@ #.module reference) (value@ #.module subject)) + ("lux i64 =" (value@ #.line reference) (value@ #.line subject)) + ("lux i64 =" (value@ #.column reference) (value@ #.column subject))))) (def: .public dummy Location @@ -23,12 +23,12 @@ (here))} (case tokens #.End - (let [location (get@ #.location compiler)] + (let [location (value@ #.location compiler)] (#.Right [compiler (list (` (.: .Location - [(~ [..dummy (#.Text (get@ #.module location))]) - (~ [..dummy (#.Nat (get@ #.line location))]) - (~ [..dummy (#.Nat (get@ #.column location))])])))])) + [(~ [..dummy (#.Text (value@ #.module location))]) + (~ [..dummy (#.Nat (value@ #.line location))]) + (~ [..dummy (#.Nat (value@ #.column location))])])))])) _ (#.Left (`` (("lux in-module" (~~ (static .prelude_module)) wrong_syntax_error) (name_of ..here)))))) diff --git a/stdlib/source/library/lux/target/js.lux b/stdlib/source/library/lux/target/js.lux index 95c49a200..191b5520a 100644 --- a/stdlib/source/library/lux/target/js.lux +++ b/stdlib/source/library/lux/target/js.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- Location Code or and function if cond undefined for comment not int try) + [lux (#- Location Code or and function if cond undefined for comment not int try ++ --) [control [pipe (#+ case>)]] [data diff --git a/stdlib/source/library/lux/target/jvm/attribute/code.lux b/stdlib/source/library/lux/target/jvm/attribute/code.lux index 1c1cb95a9..81f487d2d 100644 --- a/stdlib/source/library/lux/target/jvm/attribute/code.lux +++ b/stdlib/source/library/lux/target/jvm/attribute/code.lux @@ -37,19 +37,19 @@ ... u4 code_length; ///unsigned.bytes/4 ... u1 code[code_length]; - (binary.size (get@ #code code)) + (binary.size (value@ #code code)) ... u2 exception_table_length; ///unsigned.bytes/2 ... exception_table[exception_table_length]; (|> code - (get@ #exception_table) + (value@ #exception_table) row.size (n.* /exception.length)) ... u2 attributes_count; ///unsigned.bytes/2 ... attribute_info attributes[attributes_count]; (|> code - (get@ #attributes) + (value@ #attributes) (row\map length) (row\fold n.+ 0)))) @@ -69,14 +69,14 @@ ($_ binaryF\compose ... u2 max_stack; ... u2 max_locals; - (///limit.writer (get@ #limit code)) + (///limit.writer (value@ #limit code)) ... u4 code_length; ... u1 code[code_length]; - (binaryF.binary/32 (get@ #code code)) + (binaryF.binary/32 (value@ #code code)) ... u2 exception_table_length; ... exception_table[exception_table_length]; - ((binaryF.row/16 /exception.writer) (get@ #exception_table code)) + ((binaryF.row/16 /exception.writer) (value@ #exception_table code)) ... u2 attributes_count; ... attribute_info attributes[attributes_count]; - ((binaryF.row/16 writer) (get@ #attributes code)) + ((binaryF.row/16 writer) (value@ #attributes code)) )) diff --git a/stdlib/source/library/lux/target/jvm/bytecode.lux b/stdlib/source/library/lux/target/jvm/bytecode.lux index 87b0a75c5..a97f4a1c2 100644 --- a/stdlib/source/library/lux/target/jvm/bytecode.lux +++ b/stdlib/source/library/lux/target/jvm/bytecode.lux @@ -105,9 +105,9 @@ (function (_ [pool environment tracker]) (#try.Success [[pool environment - (update@ #next inc tracker)] + (revised@ #next ++ tracker)] [..relative_identity - (get@ #next tracker)]]))) + (value@ #next tracker)]]))) (exception: .public (label_has_already_been_set {label Label}) (exception.report @@ -127,16 +127,16 @@ (with_expansions [<success> (as_is (in [[pool environment - (update@ #known - (dictionary.has label [actual (#.Some @here)]) - tracker)] + (revised@ #known + (dictionary.has label [actual (#.Some @here)]) + tracker)] [..relative_identity []]]))] (def: .public (set_label label) (-> Label (Bytecode Any)) (function (_ [pool environment tracker]) - (let [@here (get@ #program_counter tracker)] - (case (dictionary.value label (get@ #known tracker)) + (let [@here (value@ #program_counter tracker)] + (case (dictionary.value label (value@ #known tracker)) (#.Some [expected (#.Some address)]) (exception.except ..label_has_already_been_set [label]) @@ -148,7 +148,7 @@ #.None (do try.monad [[actual environment] (/environment.continue (|> environment - (get@ #/environment.stack) + (value@ #/environment.stack) (maybe.else /stack.empty)) environment)] <success>)))))) @@ -175,7 +175,7 @@ (function (_ pool) (do try.monad [[[pool environment tracker] [relative output]] (bytecode [pool environment ..fresh]) - [exceptions instruction] (relative (get@ #known tracker))] + [exceptions instruction] (relative (value@ #known tracker))] (in [pool [environment exceptions instruction output]])))) (def: (step estimator counter) @@ -188,12 +188,12 @@ (do {! try.monad} [environment' (|> environment (/environment.consumes consumption) - (monad.bind ! (/environment.produces production)) - (monad.bind ! (/environment.has registry))) - program_counter' (step estimator (get@ #program_counter tracker))] + (monad.then ! (/environment.produces production)) + (monad.then ! (/environment.has registry))) + program_counter' (step estimator (value@ #program_counter tracker))] (in [[pool environment' - (set@ #program_counter program_counter' tracker)] + (with@ #program_counter program_counter' tracker)] [(function.constant (in [..no_exceptions (bytecode input)])) []]])))) @@ -721,19 +721,19 @@ (def: (acknowledge_label stack label tracker) (-> Stack Label Tracker Tracker) - (case (dictionary.value label (get@ #known tracker)) + (case (dictionary.value label (value@ #known tracker)) (#.Some _) tracker #.None - (update@ #known (dictionary.has label [stack #.None]) tracker))) + (revised@ #known (dictionary.has label [stack #.None]) tracker))) (template [<consumption> <name> <instruction>] [(def: .public (<name> label) (-> Label (Bytecode Any)) (let [[estimator bytecode] <instruction>] (function (_ [pool environment tracker]) - (let [@here (get@ #program_counter tracker)] + (let [@here (value@ #program_counter tracker)] (do try.monad [environment' (|> environment (/environment.consumes <consumption>)) @@ -744,7 +744,7 @@ environment' (|> tracker (..acknowledge_label actual label) - (set@ #program_counter program_counter'))] + (with@ #program_counter program_counter'))] [(function (_ resolver) (do try.monad [[expected @to] (..resolve_label label resolver) @@ -787,14 +787,14 @@ (function (_ [pool environment tracker]) (do try.monad [actual (/environment.stack environment) - .let [@here (get@ #program_counter tracker)] + .let [@here (value@ #program_counter tracker)] program_counter' (step estimator @here)] (in (let [@from @here] [[pool (/environment.discontinue environment) (|> tracker (..acknowledge_label actual label) - (set@ #program_counter program_counter'))] + (with@ #program_counter program_counter'))] [(function (_ resolver) (case (dictionary.value label resolver) (#.Some [expected (#.Some @to)]) @@ -843,22 +843,22 @@ [environment' (|> environment (/environment.consumes $1)) actual (/environment.stack environment') - program_counter' (step (estimator (list.size afterwards)) (get@ #program_counter tracker))] - (in (let [@from (get@ #program_counter tracker)] + program_counter' (step (estimator (list.size afterwards)) (value@ #program_counter tracker))] + (in (let [@from (value@ #program_counter tracker)] [[pool environment' (|> (list\fold (..acknowledge_label actual) tracker (list& default at_minimum afterwards)) - (set@ #program_counter program_counter'))] + (with@ #program_counter program_counter'))] [(function (_ resolver) (let [get (: (-> Label (Maybe [Stack (Maybe Address)])) (function (_ label) (dictionary.value label resolver)))] (case (do {! maybe.monad} - [@default (|> default get (monad.bind ! product.right)) - @at_minimum (|> at_minimum get (monad.bind ! product.right)) + [@default (|> default get (monad.then ! product.right)) + @at_minimum (|> at_minimum get (monad.then ! product.right)) @afterwards (|> afterwards (monad.map ! get) - (monad.bind ! (monad.map ! product.right)))] + (monad.then ! (monad.map ! product.right)))] (in [@default @at_minimum @afterwards])) (#.Some [@default @at_minimum @afterwards]) (do {! try.monad} @@ -886,21 +886,21 @@ [environment' (|> environment (/environment.consumes $1)) actual (/environment.stack environment') - program_counter' (step (estimator (list.size cases)) (get@ #program_counter tracker))] - (in (let [@from (get@ #program_counter tracker)] + program_counter' (step (estimator (list.size cases)) (value@ #program_counter tracker))] + (in (let [@from (value@ #program_counter tracker)] [[pool environment' (|> (list\fold (..acknowledge_label actual) tracker (list& default (list\map product.right cases))) - (set@ #program_counter program_counter'))] + (with@ #program_counter program_counter'))] [(function (_ resolver) (let [get (: (-> Label (Maybe [Stack (Maybe Address)])) (function (_ label) (dictionary.value label resolver)))] (case (do {! maybe.monad} - [@default (|> default get (monad.bind ! product.right)) + [@default (|> default get (monad.then ! product.right)) @cases (|> cases (monad.map ! (|>> product.right get)) - (monad.bind ! (monad.map ! product.right)))] + (monad.then ! (monad.map ! product.right)))] (in [@default @cases])) (#.Some [@default @cases]) (do {! try.monad} diff --git a/stdlib/source/library/lux/target/jvm/bytecode/environment.lux b/stdlib/source/library/lux/target/jvm/bytecode/environment.lux index 6a09af8fd..54c754dc5 100644 --- a/stdlib/source/library/lux/target/jvm/bytecode/environment.lux +++ b/stdlib/source/library/lux/target/jvm/bytecode/environment.lux @@ -51,7 +51,7 @@ (def: .public (stack environment) (-> Environment (Try Stack)) - (case (get@ #..stack environment) + (case (value@ #..stack environment) (#.Some stack) (#try.Success stack) @@ -60,7 +60,7 @@ (def: .public discontinue (-> Environment Environment) - (set@ #..stack #.None)) + (with@ #..stack #.None)) (exception: .public (mismatched_stacks {expected Stack} {actual Stack}) @@ -70,14 +70,14 @@ (def: .public (continue expected environment) (-> Stack Environment (Try [Stack Environment])) - (case (get@ #..stack environment) + (case (value@ #..stack environment) (#.Some actual) (if (\ /stack.equivalence = expected actual) (#try.Success [actual environment]) (exception.except ..mismatched_stacks [expected actual])) #.None - (#try.Success [expected (set@ #..stack (#.Some expected) environment)]))) + (#try.Success [expected (with@ #..stack (#.Some expected) environment)]))) (def: .public (consumes amount) (-> U2 Condition) @@ -87,7 +87,7 @@ (do try.monad [previous (..stack environment) current (/stack.pop amount previous)] - (in (set@ #..stack (#.Some current) environment))))) + (in (with@ #..stack (#.Some current) environment))))) (def: .public (produces amount) (-> U2 Condition) @@ -96,13 +96,13 @@ [previous (..stack environment) current (/stack.push amount previous) .let [limit (|> environment - (get@ [#..limit #/limit.stack]) + (value@ [#..limit #/limit.stack]) (/stack.max current))]] (in (|> environment - (set@ #..stack (#.Some current)) - (set@ [#..limit #/limit.stack] limit)))))) + (with@ #..stack (#.Some current)) + (with@ [#..limit #/limit.stack] limit)))))) (def: .public (has registry) (-> Registry Condition) - (|>> (update@ [#..limit #/limit.registry] (/registry.has registry)) + (|>> (revised@ [#..limit #/limit.registry] (/registry.has registry)) #try.Success)) diff --git a/stdlib/source/library/lux/target/jvm/bytecode/environment/limit.lux b/stdlib/source/library/lux/target/jvm/bytecode/environment/limit.lux index 48bdffd82..d57c07354 100644 --- a/stdlib/source/library/lux/target/jvm/bytecode/environment/limit.lux +++ b/stdlib/source/library/lux/target/jvm/bytecode/environment/limit.lux @@ -53,6 +53,6 @@ (def: .public (writer limit) (Writer Limit) ($_ format\compose - (/stack.writer (get@ #stack limit)) - (/registry.writer (get@ #registry limit)) + (/stack.writer (value@ #stack limit)) + (/registry.writer (value@ #registry limit)) )) diff --git a/stdlib/source/library/lux/target/jvm/bytecode/instruction.lux b/stdlib/source/library/lux/target/jvm/bytecode/instruction.lux index 7f8638dca..2e21d2a8e 100644 --- a/stdlib/source/library/lux/target/jvm/bytecode/instruction.lux +++ b/stdlib/source/library/lux/target/jvm/bytecode/instruction.lux @@ -54,7 +54,7 @@ (def: .public result (-> Instruction Specification) - (function.apply format.no_op)) + (function.on format.no_op)) (type: Opcode Nat) @@ -596,7 +596,7 @@ (///unsigned.value ..integer_size) (///unsigned.value ..integer_size) (n.* (///unsigned.value ..big_jump_size) - (inc amount_of_afterwards))) + (++ amount_of_afterwards))) ///unsigned.u2 try.trusted)))] [estimator @@ -622,7 +622,7 @@ _ (case padding 3 (do ! [_ (binary.write/8! offset 0 binary)] - (binary.write/16! (inc offset) 0 binary)) + (binary.write/16! (++ offset) 0 binary)) 2 (binary.write/16! offset 0 binary) 1 (binary.write/8! offset 0 binary) _ (in binary)) @@ -684,7 +684,7 @@ _ (case padding 3 (do ! [_ (binary.write/8! offset 0 binary)] - (binary.write/16! (inc offset) 0 binary)) + (binary.write/16! (++ offset) 0 binary)) 2 (binary.write/16! offset 0 binary) 1 (binary.write/8! offset 0 binary) _ (in binary)) diff --git a/stdlib/source/library/lux/target/jvm/class.lux b/stdlib/source/library/lux/target/jvm/class.lux index b4cb88ec4..586cc2394 100644 --- a/stdlib/source/library/lux/target/jvm/class.lux +++ b/stdlib/source/library/lux/target/jvm/class.lux @@ -76,7 +76,7 @@ (monad.fold ! (function (_ interface @interfaces) (do ! [@interface (//constant/pool.class interface)] - (in (row.add @interface @interfaces)))) + (in (row.suffix @interface @interfaces)))) row.empty interfaces))] (in [@this @super @interfaces]))) @@ -95,8 +95,8 @@ (<| (state.result' //constant/pool.empty) (do //constant/pool.monad [classes (install_classes this super interfaces) - =fields (monad.seq //constant/pool.monad fields) - =methods (monad.seq //constant/pool.monad methods)] + =fields (monad.all //constant/pool.monad fields) + =methods (monad.all //constant/pool.monad methods)] (in [classes =fields =methods])))] (in {#magic //magic.code #minor_version //version.default_minor @@ -114,7 +114,7 @@ (Writer Class) (`` ($_ binaryF\compose (~~ (template [<writer> <slot>] - [(<writer> (get@ <slot> class))] + [(<writer> (value@ <slot> class))] [//magic.writer #magic] [//version.writer #minor_version] @@ -124,7 +124,7 @@ [//index.writer #this] [//index.writer #super])) (~~ (template [<writer> <slot>] - [((binaryF.row/16 <writer>) (get@ <slot> class))] + [((binaryF.row/16 <writer>) (value@ <slot> class))] [//index.writer #interfaces] [//field.writer #fields] diff --git a/stdlib/source/library/lux/target/jvm/constant/pool.lux b/stdlib/source/library/lux/target/jvm/constant/pool.lux index 2278889b8..346dd0f9e 100644 --- a/stdlib/source/library/lux/target/jvm/constant/pool.lux +++ b/stdlib/source/library/lux/target/jvm/constant/pool.lux @@ -53,7 +53,7 @@ (template: (!add <tag> <equivalence> <value>) [(function (_ [current pool]) (let [<value>' <value>] - (with_expansions [<try_again> (as_is (recur (.inc idx)))] + (with_expansions [<try_again> (as_is (recur (.++ idx)))] (loop [idx 0] (case (row.item idx pool) (#try.Success entry) @@ -77,7 +77,7 @@ (//unsigned.+/2 @new) (\ ! map //index.index)))] (in [[next - (row.add [current new] pool)] + (row.suffix [current new] pool)] current]))))))))]) (template: (!index <index>) diff --git a/stdlib/source/library/lux/target/jvm/encoding/signed.lux b/stdlib/source/library/lux/target/jvm/encoding/signed.lux index 8fed13354..1c03a5c47 100644 --- a/stdlib/source/library/lux/target/jvm/encoding/signed.lux +++ b/stdlib/source/library/lux/target/jvm/encoding/signed.lux @@ -58,7 +58,7 @@ (def: .public <maximum> <name> - (|> <bytes> (n.* i64.bits_per_byte) dec i64.mask :abstraction)) + (|> <bytes> (n.* i64.bits_per_byte) -- i64.mask :abstraction)) (def: .public <constructor> (-> Int (Try <name>)) diff --git a/stdlib/source/library/lux/target/jvm/field.lux b/stdlib/source/library/lux/target/jvm/field.lux index a9d783621..b8d84170d 100644 --- a/stdlib/source/library/lux/target/jvm/field.lux +++ b/stdlib/source/library/lux/target/jvm/field.lux @@ -50,7 +50,7 @@ (Writer Field) (`` ($_ binaryF\compose (~~ (template [<writer> <slot>] - [(<writer> (get@ <slot> field))] + [(<writer> (value@ <slot> field))] [modifier.writer #modifier] [//index.writer #name] diff --git a/stdlib/source/library/lux/target/jvm/loader.lux b/stdlib/source/library/lux/target/jvm/loader.lux index 549fb8b01..3d644cf5d 100644 --- a/stdlib/source/library/lux/target/jvm/loader.lux +++ b/stdlib/source/library/lux/target/jvm/loader.lux @@ -66,13 +66,13 @@ (def: java/lang/ClassLoader::defineClass java/lang/reflect/Method (let [signature (|> (ffi.array <elemT> 4) - (ffi.array_write 0 (:as <elemT> - (ffi.class_for java/lang/String))) - (ffi.array_write 1 (java/lang/Object::getClass (ffi.array byte 0))) - (ffi.array_write 2 (:as <elemT> - (java/lang/Integer::TYPE))) - (ffi.array_write 3 (:as <elemT> - (java/lang/Integer::TYPE))))] + (ffi.write! 0 (:as <elemT> + (ffi.class_for java/lang/String))) + (ffi.write! 1 (java/lang/Object::getClass (ffi.array byte 0))) + (ffi.write! 2 (:as <elemT> + (java/lang/Integer::TYPE))) + (ffi.write! 3 (:as <elemT> + (java/lang/Integer::TYPE))))] (do_to (java/lang/Class::getDeclaredMethod "defineClass" signature (ffi.class_for java/lang/ClassLoader)) diff --git a/stdlib/source/library/lux/target/jvm/method.lux b/stdlib/source/library/lux/target/jvm/method.lux index 8c42130d1..e604eb3c2 100644 --- a/stdlib/source/library/lux/target/jvm/method.lux +++ b/stdlib/source/library/lux/target/jvm/method.lux @@ -54,7 +54,7 @@ [@name (//constant/pool.utf8 name) @descriptor (//constant/pool.descriptor (//type.descriptor type)) attributes (|> attributes - (monad.seq !) + (monad.all !) (\ ! map row.of_list)) attributes (case code (#.Some code) @@ -69,11 +69,11 @@ (function (_ _) (#try.Failure error))) [environment exceptions instruction output] (//bytecode.resolve environment code) .let [bytecode (|> instruction //bytecode/instruction.result format.instance)] - @code (//attribute.code {#//attribute/code.limit (get@ #//bytecode/environment.limit environment) + @code (//attribute.code {#//attribute/code.limit (value@ #//bytecode/environment.limit environment) #//attribute/code.code bytecode #//attribute/code.exception_table exceptions #//attribute/code.attributes (row.row)})] - (in (row.add @code attributes))) + (in (row.suffix @code attributes))) #.None (in attributes))] @@ -95,7 +95,7 @@ (Writer Method) (`` ($_ format\compose (~~ (template [<writer> <slot>] - [(<writer> (get@ <slot> field))] + [(<writer> (value@ <slot> field))] [//modifier.writer #modifier] [//index.writer #name] diff --git a/stdlib/source/library/lux/target/jvm/reflection.lux b/stdlib/source/library/lux/target/jvm/reflection.lux index f68b6b59d..db554e4fb 100644 --- a/stdlib/source/library/lux/target/jvm/reflection.lux +++ b/stdlib/source/library/lux/target/jvm/reflection.lux @@ -132,7 +132,7 @@ (#try.Success class) (#try.Failure _) - (exception.except ..unknown_class name))) + (exception.except ..unknown_class [name]))) (def: .public (sub? class_loader super sub) (-> java/lang/ClassLoader External External (Try Bit)) @@ -182,10 +182,10 @@ paramsT))) _ - (exception.except ..not_a_class raw))) + (exception.except ..not_a_class [raw]))) _) ... else - (exception.except ..cannot_convert_to_a_lux_type reflection))) + (exception.except ..cannot_convert_to_a_lux_type [reflection]))) (def: .public (parameter reflection) (-> java/lang/reflect/Type (Try (/.Type Parameter))) diff --git a/stdlib/source/library/lux/target/jvm/type/descriptor.lux b/stdlib/source/library/lux/target/jvm/type/descriptor.lux index 9c0f56021..099a68287 100644 --- a/stdlib/source/library/lux/target/jvm/type/descriptor.lux +++ b/stdlib/source/library/lux/target/jvm/type/descriptor.lux @@ -98,7 +98,7 @@ (:abstraction (format (|> inputs (list\map ..descriptor) - text.joined + text.together (text.enclosed ["(" ")"])) (:representation output)))) diff --git a/stdlib/source/library/lux/target/jvm/type/lux.lux b/stdlib/source/library/lux/target/jvm/type/lux.lux index a9021109b..99845fa7e 100644 --- a/stdlib/source/library/lux/target/jvm/type/lux.lux +++ b/stdlib/source/library/lux/target/jvm/type/lux.lux @@ -135,7 +135,7 @@ (<>.before (<text>.this //signature.parameters_end)) (<>.else (list)))] (in (do {! check.monad} - [parameters (monad.seq ! parameters)] + [parameters (monad.all ! parameters)] (in (#.Primitive name parameters))))) (<>.after (<text>.this //descriptor.class_prefix)) (<>.before (<text>.this //descriptor.class_suffix)))) diff --git a/stdlib/source/library/lux/target/jvm/type/signature.lux b/stdlib/source/library/lux/target/jvm/type/signature.lux index 683ba1432..7195c4918 100644 --- a/stdlib/source/library/lux/target/jvm/type/signature.lux +++ b/stdlib/source/library/lux/target/jvm/type/signature.lux @@ -78,8 +78,13 @@ [upper ..upper_prefix] ) - (def: .public parameters_start "<") - (def: .public parameters_end ">") + (template [<char> <name>] + [(def: .public <name> + <char>)] + + ["<" parameters_start] + [">" parameters_end] + ) (def: .public (class name parameters) (-> External (List (Signature Parameter)) (Signature Class)) @@ -94,7 +99,7 @@ (format ..parameters_start (|> parameters (list\map ..signature) - text.joined) + text.together) ..parameters_end)) //descriptor.class_suffix))) @@ -130,18 +135,18 @@ (|> type_variables (list\map (|>> ..var_name (text.suffix ..class_bound))) - text.joined + text.together (text.enclosed [..parameters_start ..parameters_end]))) (|> inputs (list\map ..signature) - text.joined + text.together (text.enclosed [..arguments_start ..arguments_end])) (:representation output) (|> exceptions (list\map (|>> :representation (format ..exception_prefix))) - text.joined)))) + text.together)))) (implementation: .public equivalence (All [category] (Equivalence (Signature category))) diff --git a/stdlib/source/library/lux/target/lua.lux b/stdlib/source/library/lux/target/lua.lux index b79db8fc4..b70cf80f0 100644 --- a/stdlib/source/library/lux/target/lua.lux +++ b/stdlib/source/library/lux/target/lua.lux @@ -374,7 +374,7 @@ (syntax: (arity_inputs [arity <code>.nat]) (in (case arity 0 (.list) - _ (|> (dec arity) + _ (|> (-- arity) (enum.range n.enum 0) (list\map (|>> %.nat code.local_identifier)))))) diff --git a/stdlib/source/library/lux/target/php.lux b/stdlib/source/library/lux/target/php.lux index 11aea7808..860c33713 100644 --- a/stdlib/source/library/lux/target/php.lux +++ b/stdlib/source/library/lux/target/php.lux @@ -230,7 +230,7 @@ (syntax: (arity_inputs [arity <code>.nat]) (in (case arity 0 (.list) - _ (|> (dec arity) + _ (|> (-- arity) (enum.range n.enum 0) (list\map (|>> %.nat code.local_identifier)))))) @@ -481,10 +481,10 @@ (def: (catch except) (-> Except Text) - (let [declaration (format (:representation (get@ #class except)) - " " (:representation (get@ #exception except)))] + (let [declaration (format (:representation (value@ #class except)) + " " (:representation (value@ #exception except)))] (format "catch" (..group declaration) " " - (..block (:representation (get@ #handler except)))))) + (..block (:representation (value@ #handler except)))))) (def: .public (try body! excepts) (-> Statement (List Except) Statement) diff --git a/stdlib/source/library/lux/target/python.lux b/stdlib/source/library/lux/target/python.lux index c8a62c58b..06ad85593 100644 --- a/stdlib/source/library/lux/target/python.lux +++ b/stdlib/source/library/lux/target/python.lux @@ -243,7 +243,7 @@ (format (:representation func) (format "(" (|> args (list\map (function (_ arg) (format (:representation arg) ", "))) - text.joined) + text.together) (<splat> extra) ")"))))] [apply_poly splat_poly] @@ -268,7 +268,7 @@ [do_keyword apply_keyword] ) - (def: .public (nth idx array) + (def: .public (item idx array) (-> (Expression Any) (Expression Any) Location) (:abstraction (format (:representation array) "[" (:representation idx) "]"))) @@ -409,7 +409,7 @@ (format text.new_line "except (" (text.interposed ", " (list\map ..code classes)) ") as " (:representation exception) ":" (..nested (:representation catch!))))) - text.joined)))) + text.together)))) (template [<name> <keyword> <pre>] [(def: .public (<name> value) @@ -460,7 +460,7 @@ (syntax: (arity_inputs [arity <code>.nat]) (in (case arity 0 (.list) - _ (|> (dec arity) + _ (|> (-- arity) (enum.range n.enum 0) (list\map (|>> %.nat code.local_identifier)))))) diff --git a/stdlib/source/library/lux/target/r.lux b/stdlib/source/library/lux/target/r.lux index 15804b77b..d5344a1c9 100644 --- a/stdlib/source/library/lux/target/r.lux +++ b/stdlib/source/library/lux/target/r.lux @@ -170,7 +170,7 @@ (let [func (:representation func) spacing (|> " " (list.repeated (text.size func)) - text.joined)] + text.together)] (:abstraction (format func "(" (|> args diff --git a/stdlib/source/library/lux/target/ruby.lux b/stdlib/source/library/lux/target/ruby.lux index 032ebb265..954a91d97 100644 --- a/stdlib/source/library/lux/target/ruby.lux +++ b/stdlib/source/library/lux/target/ruby.lux @@ -436,7 +436,7 @@ (syntax: (arity_inputs [arity <code>.nat]) (in (case arity 0 (.list) - _ (|> (dec arity) + _ (|> (-- arity) (enum.range n.enum 0) (list\map (|>> %.nat code.local_identifier)))))) diff --git a/stdlib/source/library/lux/target/scheme.lux b/stdlib/source/library/lux/target/scheme.lux index 7e910a91f..4390d9981 100644 --- a/stdlib/source/library/lux/target/scheme.lux +++ b/stdlib/source/library/lux/target/scheme.lux @@ -341,7 +341,7 @@ (-> Var Arguments Expression Computation) (..form (list (..var "define") (|> arguments - (update@ #mandatory (|>> (#.Item name))) + (revised@ #mandatory (|>> (#.Item name))) ..arguments) body))) diff --git a/stdlib/source/library/lux/test.lux b/stdlib/source/library/lux/test.lux index dbd87627e..29af87345 100644 --- a/stdlib/source/library/lux/test.lux +++ b/stdlib/source/library/lux/test.lux @@ -50,12 +50,12 @@ (def: (total parameter subject) (-> Tally Tally Tally) - {#successes (n.+ (get@ #successes parameter) (get@ #successes subject)) - #failures (n.+ (get@ #failures parameter) (get@ #failures subject)) - #expected_coverage (set.union (get@ #expected_coverage parameter) - (get@ #expected_coverage subject)) - #actual_coverage (set.union (get@ #actual_coverage parameter) - (get@ #actual_coverage subject))}) + {#successes (n.+ (value@ #successes parameter) (value@ #successes subject)) + #failures (n.+ (value@ #failures parameter) (value@ #failures subject)) + #expected_coverage (set.union (value@ #expected_coverage parameter) + (value@ #expected_coverage subject)) + #actual_coverage (set.union (value@ #actual_coverage parameter) + (value@ #actual_coverage subject))}) (def: start Tally @@ -67,7 +67,7 @@ (template [<name> <category>] [(def: <name> Tally - (update@ <category> .inc ..start))] + (revised@ <category> .++ ..start))] [success_tally #successes] [failure_tally #failures] @@ -166,7 +166,7 @@ (def: failed? (-> Tally Bit) - (|>> (get@ #failures) (n.> 0))) + (|>> (value@ #failures) (n.> 0))) (def: (times_failure seed documentation) (-> Seed Text Text) @@ -193,26 +193,26 @@ (case amount 1 instance _ (|> test - (times (dec amount)) + (times (-- amount)) (random.result prng') product.right))))]))))) (def: (description duration tally) (-> Duration Tally Text) - (let [successes (get@ #successes tally) - failures (get@ #failures tally) - missing (set.difference (get@ #actual_coverage tally) - (get@ #expected_coverage tally)) - unexpected (set.difference (get@ #expected_coverage tally) - (get@ #actual_coverage tally)) + (let [successes (value@ #successes tally) + failures (value@ #failures tally) + missing (set.difference (value@ #actual_coverage tally) + (value@ #expected_coverage tally)) + unexpected (set.difference (value@ #expected_coverage tally) + (value@ #actual_coverage tally)) report (: (-> (Set Name) Text) (|>> set.list (list.sorted (\ name.order <)) (exception.listing %.name))) - expected_definitions_to_cover (set.size (get@ #expected_coverage tally)) + expected_definitions_to_cover (set.size (value@ #expected_coverage tally)) unexpected_definitions_covered (set.size unexpected) actual_definitions_covered (n.- unexpected_definitions_covered - (set.size (get@ #actual_coverage tally))) + (set.size (value@ #actual_coverage tally))) coverage (case expected_definitions_to_cover 0 "N/A" expected (let [missing_ratio (f./ (n.frac expected) @@ -265,7 +265,7 @@ (..description duration tally) text.new_line))]] (async.future (\ program.default exit - (case (get@ #failures tally) + (case (value@ #failures tally) 0 ..success_exit_code _ ..failure_exit_code))))) @@ -277,7 +277,7 @@ coverage (set.of_list name.hash coverage)] (|> (..assertion message condition) (async\map (function (_ [tally documentation]) - [(update@ #actual_coverage (set.union coverage) tally) + [(revised@ #actual_coverage (set.union coverage) tally) documentation]))))) (def: (|cover| coverage condition) @@ -292,7 +292,7 @@ (text.interposed " & ")) coverage (set.of_list name.hash coverage)] (random\map (async\map (function (_ [tally documentation]) - [(update@ #actual_coverage (set.union coverage) tally) + [(revised@ #actual_coverage (set.union coverage) tally) documentation])) (..context context test)))) @@ -369,7 +369,7 @@ (let [coverage (..decode_coverage module coverage)] (|> (..context module test) (random\map (async\map (function (_ [tally documentation]) - [(update@ #expected_coverage (set.union coverage) tally) + [(revised@ #expected_coverage (set.union coverage) tally) documentation])))))) (syntax: .public (covering [module <code>.identifier diff --git a/stdlib/source/library/lux/time.lux b/stdlib/source/library/lux/time.lux index eb0928f5c..c6206e167 100644 --- a/stdlib/source/library/lux/time.lux +++ b/stdlib/source/library/lux/time.lux @@ -46,7 +46,7 @@ (exception: .public (time_exceeds_a_day {time Nat}) (exception.report ["Time (in milli-seconds)" (n\encode time)] - ["Maximum (in milli-seconds)" (n\encode (dec limit))])) + ["Maximum (in milli-seconds)" (n\encode (-- limit))])) (def: separator ":") @@ -66,7 +66,7 @@ (exception.report ["Value" (n\encode value)] ["Minimum" (n\encode 0)] - ["Maximum" (n\encode (dec <maximum>))])) + ["Maximum" (n\encode (-- <maximum>))])) (def: <parser> (Parser Nat) @@ -121,13 +121,13 @@ (def: &order ..order) (def: succ - (|>> :representation inc (n.% ..limit) :abstraction)) + (|>> :representation ++ (n.% ..limit) :abstraction)) (def: pred (|>> :representation (case> 0 ..limit millis millis) - dec + -- :abstraction)))) (def: .public parser @@ -197,10 +197,10 @@ (def: .public (time clock) (-> Clock (Try Time)) (|> ($_ duration.merged - (duration.up (get@ #hour clock) duration.hour) - (duration.up (get@ #minute clock) duration.minute) - (duration.up (get@ #second clock) duration.second) - (duration.of_millis (.int (get@ #milli_second clock)))) + (duration.up (value@ #hour clock) duration.hour) + (duration.up (value@ #minute clock) duration.minute) + (duration.up (value@ #second clock) duration.second) + (duration.of_millis (.int (value@ #milli_second clock)))) duration.millis .nat ..of_millis)) diff --git a/stdlib/source/library/lux/time/date.lux b/stdlib/source/library/lux/time/date.lux index 75e5609ea..d06910711 100644 --- a/stdlib/source/library/lux/time/date.lux +++ b/stdlib/source/library/lux/time/date.lux @@ -95,7 +95,7 @@ (template [<name> <type> <field>] [(def: .public <name> (-> Date <type>) - (|>> :representation (get@ <field>)))] + (|>> :representation (value@ <field>)))] [year Year #year] [month Month #month] @@ -109,13 +109,13 @@ (let [reference (:representation reference) sample (:representation sample)] (and (\ //year.equivalence = - (get@ #year reference) - (get@ #year sample)) + (value@ #year reference) + (value@ #year sample)) (\ //month.equivalence = - (get@ #month reference) - (get@ #month sample)) - (n.= (get@ #day reference) - (get@ #day sample)))))) + (value@ #month reference) + (value@ #month sample)) + (n.= (value@ #day reference) + (value@ #day sample)))))) (implementation: .public order (Order Date) @@ -126,19 +126,19 @@ (let [reference (:representation reference) sample (:representation sample)] (or (\ //year.order < - (get@ #year reference) - (get@ #year sample)) + (value@ #year reference) + (value@ #year sample)) (and (\ //year.equivalence = - (get@ #year reference) - (get@ #year sample)) + (value@ #year reference) + (value@ #year sample)) (or (\ //month.order < - (get@ #month reference) - (get@ #month sample)) + (value@ #month reference) + (value@ #month sample)) (and (\ //month.order = - (get@ #month reference) - (get@ #month sample)) - (n.< (get@ #day reference) - (get@ #day sample))))))))) + (value@ #month reference) + (value@ #month sample)) + (n.< (value@ #day reference) + (value@ #day sample))))))))) ) (def: section_parser @@ -271,17 +271,17 @@ ..civil_month))) (def: last_era_leap_day - (.int (dec ..days_per_leap))) + (.int (-- ..days_per_leap))) (def: last_era_day - (.int (dec ..days_per_era))) + (.int (-- ..days_per_era))) (def: (civil_year utc_month utc_year) (-> Nat Year Int) (let [... Coercing, because the year is already in external form. utc_year (:as Int utc_year)] (if (n.< ..first_month_of_civil_year utc_month) - (dec utc_year) + (-- utc_year) utc_year))) ... http://howardhinnant.github.io/date_algorithms.html @@ -290,7 +290,7 @@ (let [utc_month (|> date ..month //month.number) civil_year (..civil_year utc_month (..year date)) era (|> (if (i.< +0 civil_year) - (i.- (.int (dec //year.era)) + (i.- (.int (-- //year.era)) civil_year) civil_year) (i./ (.int //year.era))) @@ -299,7 +299,7 @@ civil_year) day_of_year (|> utc_month ..day_of_year_from_month - (i.+ (.int (dec (..day_of_month date))))) + (i.+ (.int (-- (..day_of_month date))))) day_of_era (|> day_of_year (i.+ (i.* (.int //year.days) year_of_era)) (i.+ (i./ (.int //year.leap) year_of_era)) @@ -334,7 +334,7 @@ (i.+ +1) .nat) year (if (n.< ..first_month_of_civil_year month) - (inc year) + (++ year) year)] ... Coercing, because the year is already in internal form. (try.trusted @@ -348,7 +348,7 @@ (def: &order ..order) (def: succ - (|>> ..days inc ..of_days)) + (|>> ..days ++ ..of_days)) (def: pred - (|>> ..days dec ..of_days))) + (|>> ..days -- ..of_days))) diff --git a/stdlib/source/library/lux/time/instant.lux b/stdlib/source/library/lux/time/instant.lux index 36e0b2504..f454c1425 100644 --- a/stdlib/source/library/lux/time/instant.lux +++ b/stdlib/source/library/lux/time/instant.lux @@ -102,7 +102,7 @@ (let [[days millis] (i./% ..millis_per_day offset)] (case millis +0 [days millis] - _ [(dec days) (i.+ ..millis_per_day millis)])) + _ [(-- days) (i.+ ..millis_per_day millis)])) (i./% ..millis_per_day offset))] [(date.of_days days) (duration.of_millis day_time)])) @@ -214,7 +214,7 @@ day_time (duration.framed duration.day offset) days (if (and (duration.negative? offset) (not (duration.neutral? day_time))) - (dec days) + (-- days) days) ... 1970/01/01 was a Thursday y1970m0d0 +4] diff --git a/stdlib/source/library/lux/time/month.lux b/stdlib/source/library/lux/time/month.lux index d8203e175..07fcc6269 100644 --- a/stdlib/source/library/lux/time/month.lux +++ b/stdlib/source/library/lux/time/month.lux @@ -184,7 +184,7 @@ {#.doc (example "The amount of days of a month (in a leap year).")} (-> Month Nat) (case month - #February (inc (..days month)) + #February (++ (..days month)) _ (..days month))) (def: .public year diff --git a/stdlib/source/library/lux/time/year.lux b/stdlib/source/library/lux/time/year.lux index dd303ed85..3eb12ad90 100644 --- a/stdlib/source/library/lux/time/year.lux +++ b/stdlib/source/library/lux/time/year.lux @@ -23,14 +23,14 @@ (def: (internal year) (-> Int Int) (if (i.< +0 year) - (inc year) + (++ year) year)) (def: (external year) (-> Int Int) (if (i.> +0 year) year - (dec year))) + (-- year))) (exception: .public there_is_no_year_0) @@ -100,8 +100,8 @@ (-> Year Int) (let [year (|> year ..value ..internal) limit (if (i.> +0 year) - (dec year) - (inc year))] + (-- year) + (++ year))] (`` (|> +0 (~~ (template [<polarity> <years>] [(<polarity> (i./ (.int <years>) limit))] diff --git a/stdlib/source/library/lux/tool/compiler/default/init.lux b/stdlib/source/library/lux/tool/compiler/default/init.lux index e8b91db8c..04971dadd 100644 --- a/stdlib/source/library/lux/tool/compiler/default/init.lux +++ b/stdlib/source/library/lux/tool/compiler/default/init.lux @@ -107,8 +107,8 @@ (#.Right [source' output]) (let [[location _] output] (#try.Success [[bundle (|> compiler - (set@ #.source source') - (set@ #.location location))] + (with@ #.source source') + (with@ #.location location))] [source' output]]))))) (type: (Operation a) @@ -125,13 +125,13 @@ (///directive.Operation anchor expression directive [Source (Payload directive)]))) (do ///phase.monad - [.let [module (get@ #///.module input)] + [.let [module (value@ #///.module input)] _ (///directive.set_current_module module)] (///directive.lifted_analysis (do {! ///phase.monad} [_ (module.create hash module) _ (monad.map ! module.import dependencies) - .let [source (///analysis.source (get@ #///.module input) (get@ #///.code input))] + .let [source (///analysis.source (value@ #///.module input) (value@ #///.code input))] _ (///analysis.set_source_code source)] (in [source [///generation.empty_buffer artifact.empty]]))))) @@ -220,13 +220,13 @@ (def: (default_dependencies prelude input) (-> Module ///.Input (List Module)) (list& archive.runtime_module - (if (text\= prelude (get@ #///.module input)) + (if (text\= prelude (value@ #///.module input)) (list) (list prelude)))) (def: module_aliases (-> .Module Aliases) - (|>> (get@ #.module_aliases) (dictionary.of_list text.hash))) + (|>> (value@ #.module_aliases) (dictionary.of_list text.hash))) (def: .public (compiler expander prelude write_directive) (All [anchor expression directive] @@ -238,10 +238,10 @@ {#///.dependencies dependencies #///.process (function (_ state archive) (do {! try.monad} - [.let [hash (text\hash (get@ #///.code input))] + [.let [hash (text\hash (value@ #///.code input))] [state [source buffer]] (<| (///phase.result' state) (..begin dependencies hash input)) - .let [module (get@ #///.module input)]] + .let [module (value@ #///.module input)]] (loop [iteration (<| (///phase.result' state) (..iteration archive expander module source buffer ///syntax.no_aliases))] (do ! @@ -252,7 +252,7 @@ [[state [analysis_module [final_buffer final_registry]]] (///phase.result' state (..end module)) .let [descriptor {#descriptor.hash hash #descriptor.name module - #descriptor.file (get@ #///.file input) + #descriptor.file (value@ #///.file input) #descriptor.references (set.of_list text.hash dependencies) #descriptor.state #.Compiled #descriptor.registry final_registry}]] @@ -267,7 +267,7 @@ (let [[temporary_buffer temporary_registry] temporary_payload] (in [state (#.Left {#///.dependencies (|> requirements - (get@ #///directive.imports) + (value@ #///directive.imports) (list\map product.left)) #///.process (function (_ state archive) (recur (<| (///phase.result' state) @@ -281,7 +281,7 @@ _ (///directive.lifted_generation (///generation.set_registry temporary_registry)) _ (|> requirements - (get@ #///directive.referrals) + (value@ #///directive.referrals) (monad.map ! (execute! archive))) temporary_payload (..get_current_payload temporary_payload)] (..iteration archive expander module source temporary_payload (..module_aliases analysis_module))))))})])) diff --git a/stdlib/source/library/lux/tool/compiler/default/platform.lux b/stdlib/source/library/lux/tool/compiler/default/platform.lux index 53cb07e22..1ac28821f 100644 --- a/stdlib/source/library/lux/tool/compiler/default/platform.lux +++ b/stdlib/source/library/lux/tool/compiler/default/platform.lux @@ -97,7 +97,7 @@ (All [<type_vars>] (-> Static <Platform> archive.ID [Descriptor (Document Any) Output] (Async (Try Any)))) - (let [system (get@ #&file_system platform) + (let [system (value@ #&file_system platform) write_artifact! (: (-> [artifact.ID (Maybe Text) Binary] (Action Any)) (function (_ [artifact_id custom content]) (ioW.write system static module_id artifact_id content)))] @@ -129,7 +129,7 @@ (-> <Platform> (///generation.Operation <type_vars> [Registry Output]))) (do ///phase.monad [_ ..initialize_buffer!] - (get@ #runtime platform))) + (value@ #runtime platform))) (def: (runtime_descriptor registry) (-> Registry Descriptor) @@ -198,7 +198,7 @@ (def: (phase_wrapper archive platform state) (All [<type_vars>] (-> Archive <Platform> <State+> (Try [<State+> Phase_Wrapper]))) - (let [phase_wrapper (get@ #phase_wrapper platform)] + (let [phase_wrapper (value@ #phase_wrapper platform)] (|> archive phase_wrapper ///directive.lifted_generation @@ -236,15 +236,15 @@ Import (List Context) (Async (Try [<State+> Archive])))) (do {! (try.with async.monad)} - [.let [state (//init.state (get@ #static.host static) + [.let [state (//init.state (value@ #static.host static) module expander host_analysis - (get@ #host platform) - (get@ #phase platform) + (value@ #host platform) + (value@ #phase platform) generation_bundle)] - _ (ioW.enable (get@ #&file_system platform) static) - [archive analysis_state bundles] (ioW.thaw (get@ #host platform) (get@ #&file_system platform) static import compilation_sources) + _ (ioW.enable (value@ #&file_system platform) static) + [archive analysis_state bundles] (ioW.thaw (value@ #host platform) (value@ #&file_system platform) static import compilation_sources) .let [with_missing_extensions (: (All [<type_vars>] (-> <Platform> (Program expression directive) <State+> (Async (Try <State+>)))) @@ -276,11 +276,11 @@ (def: (module_compilation_log module) (All [<type_vars>] (-> Module <State+> Text)) - (|>> (get@ [#extension.state - #///directive.generation - #///directive.state - #extension.state - #///generation.log]) + (|>> (value@ [#extension.state + #///directive.generation + #///directive.state + #extension.state + #///generation.log]) (row\fold (function (_ right left) (format left ..compilation_log_separator right)) module))) @@ -288,12 +288,12 @@ (def: with_reset_log (All [<type_vars>] (-> <State+> <State+>)) - (set@ [#extension.state - #///directive.generation - #///directive.state - #extension.state - #///generation.log] - row.empty)) + (with@ [#extension.state + #///directive.generation + #///directive.state + #extension.state + #///generation.log] + row.empty)) (def: empty (Set Module) @@ -320,8 +320,8 @@ lens (dictionary.value module) (maybe.else ..empty)))) - transitive_depends_on (transitive_dependency (get@ #depends_on) import) - transitive_depended_by (transitive_dependency (get@ #depended_by) module) + transitive_depends_on (transitive_dependency (value@ #depends_on) import) + transitive_depended_by (transitive_dependency (value@ #depended_by) module) update_dependence (: (-> [Module (Set Module)] [Module (Set Module)] (-> Mapping Mapping)) (function (_ [source forward] [target backward]) @@ -335,14 +335,14 @@ with_dependence+transitives (set.list backward))))))] (|> dependence - (update@ #depends_on - (update_dependence - [module transitive_depends_on] - [import transitive_depended_by])) - (update@ #depended_by - ((function.flipped update_dependence) - [module transitive_depends_on] - [import transitive_depended_by]))))) + (revised@ #depends_on + (update_dependence + [module transitive_depends_on] + [import transitive_depended_by])) + (revised@ #depended_by + ((function.flipped update_dependence) + [module transitive_depends_on] + [import transitive_depended_by]))))) (def: (circular_dependency? module import dependence) (-> Module Module Dependence Bit) @@ -353,8 +353,8 @@ (dictionary.value from) (maybe.else ..empty))] (set.member? targets to))))] - (or (dependence? import (get@ #depends_on) module) - (dependence? module (get@ #depended_by) import)))) + (or (dependence? import (value@ #depends_on) module) + (dependence? module (value@ #depended_by) import)))) (exception: .public (module_cannot_import_itself {module Module}) (exception.report @@ -499,21 +499,21 @@ .let [additions (|> modules (list\map product.left) (set.of_list text.hash))]] - (in (update@ [#extension.state - #///directive.analysis - #///directive.state - #extension.state] - (function (_ analysis_state) - (|> analysis_state - (:as .Lux) - (update@ #.modules (function (_ current) - (list\compose (list.only (|>> product.left - (set.member? additions) - not) - current) - modules))) - :expected)) - state)))) + (in (revised@ [#extension.state + #///directive.analysis + #///directive.state + #extension.state] + (function (_ analysis_state) + (|> analysis_state + (:as .Lux) + (revised@ #.modules (function (_ current) + (list\compose (list.only (|>> product.left + (set.member? additions) + not) + current) + modules))) + :expected)) + state)))) (def: (set_current_module module state) (All [<type_vars>] @@ -533,24 +533,24 @@ (///.Compiler <State+> .Module Any) (:expected - ((//init.compiler expander syntax.prelude (get@ #write platform)) $.key (list)))) + ((//init.compiler expander syntax.prelude (value@ #write platform)) $.key (list)))) compiler (..parallel context (function (_ importer import! module_id [archive state] module) (do {! (try.with async.monad)} [.let [state (..set_current_module module state)] - input (context.read (get@ #&file_system platform) + input (context.read (value@ #&file_system platform) importer import compilation_sources - (get@ #static.host_module_extension static) + (value@ #static.host_module_extension static) module)] (loop [[archive state] [archive state] compilation (base_compiler (:as ///.Input input)) all_dependencies (: (Set Module) (set.of_list text.hash (list)))] (do ! - [.let [new_dependencies (get@ #///.dependencies compilation) + [.let [new_dependencies (value@ #///.dependencies compilation) continue! (:sharing [<type_vars>] <Platform> platform @@ -582,14 +582,14 @@ (do ! [archive,document+ (|> new_dependencies (list\map (import! module)) - (monad.seq ..monad)) + (monad.all ..monad)) .let [archive (|> archive,document+ (list\map product.left) (list\fold archive.merged archive))]] (in [archive (try.trusted (..updated_state archive state))]))) (async\in (exception.except ..cannot_import_twice [module duplicates])))] - (case ((get@ #///.process compilation) + (case ((value@ #///.process compilation) ... TODO: The "///directive.set_current_module" below shouldn't be necessary. Remove it ASAP. ... TODO: The context shouldn't need to be re-set either. (|> (///directive.set_current_module module) @@ -605,7 +605,7 @@ (#.Right [descriptor document output]) (do ! [.let [_ (debug.log! (..module_compilation_log module state)) - descriptor (set@ #descriptor.references all_dependencies descriptor)] + descriptor (with@ #descriptor.references all_dependencies descriptor)] _ (..cache_module static platform module_id [descriptor document output])] (case (archive.has module [descriptor document output] archive) (#try.Success archive) @@ -617,7 +617,7 @@ (#try.Failure error) (do ! - [_ (ioW.freeze (get@ #&file_system platform) static archive)] + [_ (ioW.freeze (value@ #&file_system platform) static archive)] (async\in (#try.Failure error)))))))))] (compiler archive.runtime_module compilation_module))) ))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux index 571185dee..aefd908c4 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux @@ -55,18 +55,18 @@ (def: .public (tag lefts right?) (-> Nat Bit Nat) (if right? - (inc lefts) + (++ lefts) lefts)) (def: (lefts tag right?) (-> Nat Bit Nat) (if right? - (dec tag) + (-- tag) tag)) (def: .public (choice options pick) (-> Nat Nat [Nat Bit]) - (let [right? (n.= (dec options) pick)] + (let [right? (n.= (-- options) pick)] [(..lefts pick right?) right?])) @@ -253,7 +253,7 @@ (def: (last? size tag) (-> Nat Tag Bit) - (n.= (dec size) tag)) + (n.= (-- size) tag)) (template: .public (no_op value) [(|> 1 #variable.Local #reference.Variable #..Reference @@ -402,10 +402,10 @@ (def: .public (with_source_code source action) (All [a] (-> Source (Operation a) (Operation a))) (function (_ [bundle state]) - (let [old_source (get@ #.source state)] - (case (action [bundle (set@ #.source source state)]) + (let [old_source (value@ #.source state)] + (case (action [bundle (with@ #.source source state)]) (#try.Success [[bundle' state'] output]) - (#try.Success [[bundle' (set@ #.source old_source state')] + (#try.Success [[bundle' (with@ #.source old_source state')] output]) (#try.Failure error) @@ -426,11 +426,11 @@ (def: .public (with_scope action) (All [a] (-> (Operation a) (Operation [Scope a]))) (function (_ [bundle state]) - (case (action [bundle (update@ #.scopes (|>> (#.Item fresh_scope)) state)]) + (case (action [bundle (revised@ #.scopes (|>> (#.Item fresh_scope)) state)]) (#try.Success [[bundle' state'] output]) - (case (get@ #.scopes state') + (case (value@ #.scopes state') (#.Item head tail) - (#try.Success [[bundle' (set@ #.scopes tail state')] + (#try.Success [[bundle' (with@ #.scopes tail state')] [head output]]) #.End @@ -441,8 +441,8 @@ (def: .public (with_current_module name) (All [a] (-> Text (Operation a) (Operation a))) - (extension.localized (get@ #.current_module) - (set@ #.current_module) + (extension.localized (value@ #.current_module) + (with@ #.current_module) (function.constant (#.Some name)))) (def: .public (with_location location action) @@ -450,10 +450,10 @@ (if (text\= "" (product.left location)) action (function (_ [bundle state]) - (let [old_location (get@ #.location state)] - (case (action [bundle (set@ #.location location state)]) + (let [old_location (value@ #.location state)] + (case (action [bundle (with@ #.location location state)]) (#try.Success [[bundle' state'] output]) - (#try.Success [[bundle' (set@ #.location old_location state')] + (#try.Success [[bundle' (with@ #.location old_location state')] output]) (#try.Failure error) @@ -467,7 +467,7 @@ (def: .public (failure error) (-> Text Operation) (function (_ [bundle state]) - (#try.Failure (locate_error (get@ #.location state) error)))) + (#try.Failure (locate_error (value@ #.location state) error)))) (def: .public (except exception parameters) (All [e] (-> (Exception e) e Operation)) @@ -482,7 +482,7 @@ (def: .public (failure' error) (-> Text (phase.Operation Lux)) (function (_ state) - (#try.Failure (locate_error (get@ #.location state) error)))) + (#try.Failure (locate_error (value@ #.location state) error)))) (def: .public (except' exception parameters) (All [e] (-> (Exception e) e (phase.Operation Lux))) @@ -498,7 +498,7 @@ (#try.Failure error) (let [[bundle state] bundle,state] - (#try.Failure (locate_error (get@ #.location state) error)))))) + (#try.Failure (locate_error (value@ #.location state) error)))))) (def: .public (install state) (-> .Lux (Operation Any)) @@ -509,7 +509,7 @@ (template [<name> <type> <field> <value>] [(def: .public (<name> value) (-> <type> (Operation Any)) - (extension.update (set@ <field> <value>)))] + (extension.update (with@ <field> <value>)))] [set_source_code Source #.source value] [set_current_module Text #.current_module (#.Some value)] diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/directive.lux b/stdlib/source/library/lux/tool/compiler/language/lux/directive.lux index 478697fd4..5f2770068 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/directive.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/directive.lux @@ -47,8 +47,8 @@ (def: .public (merge_requirements left right) (-> Requirements Requirements Requirements) - {#imports (list\compose (get@ #imports left) (get@ #imports right)) - #referrals (list\compose (get@ #referrals left) (get@ #referrals right))}) + {#imports (list\compose (value@ #imports left) (value@ #imports right)) + #referrals (list\compose (value@ #referrals left) (value@ #referrals right))}) (template [<special> <general>] [(type: .public (<special> anchor expression directive) @@ -66,7 +66,7 @@ (All [anchor expression directive] (Operation anchor expression directive <phase>)) (function (_ [bundle state]) - (#try.Success [[bundle state] (get@ [<component> #..phase] state)])))] + (#try.Success [[bundle state] (value@ [<component> #..phase] state)])))] [analysis #..analysis analysis.Phase] [synthesis #..synthesis synthesis.Phase] @@ -78,8 +78,8 @@ (All [anchor expression directive output] (-> (<operation> output) (Operation anchor expression directive output))) - (|>> (phase.sub [(get@ [<component> #..state]) - (set@ [<component> #..state])]) + (|>> (phase.sub [(value@ [<component> #..state]) + (with@ [<component> #..state])]) extension.lifted))] [lifted_analysis #..analysis analysis.Operation] diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/generation.lux b/stdlib/source/library/lux/tool/compiler/language/lux/generation.lux index 0a1841ad1..aee61ebc7 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/generation.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/generation.lux @@ -111,9 +111,9 @@ (All [anchor expression directive output] <with_type>) (function (_ body) (function (_ [bundle state]) - (case (body [bundle (set@ <tag> (#.Some <with_value>) state)]) + (case (body [bundle (with@ <tag> (#.Some <with_value>) state)]) (#try.Success [[bundle' state'] output]) - (#try.Success [[bundle' (set@ <tag> (get@ <tag> state) state')] + (#try.Success [[bundle' (with@ <tag> (value@ <tag> state) state')] output]) (#try.Failure error) @@ -123,7 +123,7 @@ (All [anchor expression directive] (Operation anchor expression directive <get_type>)) (function (_ (^@ stateE [bundle state])) - (case (get@ <tag> state) + (case (value@ <tag> state) (#.Some output) (#try.Success [stateE output]) @@ -134,7 +134,7 @@ (All [anchor expression directive] (-> <get_type> (Operation anchor expression directive Any))) (function (_ [bundle state]) - (#try.Success [[bundle (set@ <tag> (#.Some value) state)] + (#try.Success [[bundle (with@ <tag> (#.Some value) state)] []])))] [#anchor @@ -156,21 +156,21 @@ (All [anchor expression directive] (Operation anchor expression directive artifact.Registry)) (function (_ (^@ stateE [bundle state])) - (#try.Success [stateE (get@ #registry state)]))) + (#try.Success [stateE (value@ #registry state)]))) (def: .public (set_registry value) (All [anchor expression directive] (-> artifact.Registry (Operation anchor expression directive Any))) (function (_ [bundle state]) - (#try.Success [[bundle (set@ #registry value state)] + (#try.Success [[bundle (with@ #registry value state)] []]))) (def: .public next (All [anchor expression directive] (Operation anchor expression directive Nat)) (do phase.monad - [count (extension.read (get@ #counter)) - _ (extension.update (update@ #counter inc))] + [count (extension.read (value@ #counter)) + _ (extension.update (revised@ #counter ++))] (in count))) (def: .public (identifier prefix) @@ -181,18 +181,18 @@ (def: .public (enter_module module) (All [anchor expression directive] (-> Module (Operation anchor expression directive Any))) - (extension.update (set@ #module module))) + (extension.update (with@ #module module))) (def: .public module (All [anchor expression directive] (Operation anchor expression directive Module)) - (extension.read (get@ #module))) + (extension.read (value@ #module))) (def: .public (evaluate! label code) (All [anchor expression directive] (-> Context expression (Operation anchor expression directive Any))) (function (_ (^@ state+ [bundle state])) - (case (\ (get@ #host state) evaluate! label code) + (case (\ (value@ #host state) evaluate! label code) (#try.Success output) (#try.Success [state+ output]) @@ -203,7 +203,7 @@ (All [anchor expression directive] (-> directive (Operation anchor expression directive Any))) (function (_ (^@ state+ [bundle state])) - (case (\ (get@ #host state) execute! code) + (case (\ (value@ #host state) execute! code) (#try.Success output) (#try.Success [state+ output]) @@ -214,7 +214,7 @@ (All [anchor expression directive] (-> Context (Maybe Text) expression (Operation anchor expression directive [Text Any directive]))) (function (_ (^@ stateE [bundle state])) - (case (\ (get@ #host state) define! context custom code) + (case (\ (value@ #host state) define! context custom code) (#try.Success output) (#try.Success [stateE output]) @@ -225,13 +225,13 @@ (All [anchor expression directive] (-> artifact.ID (Maybe Text) directive (Operation anchor expression directive Any))) (do {! phase.monad} - [?buffer (extension.read (get@ #buffer))] + [?buffer (extension.read (value@ #buffer))] (case ?buffer (#.Some buffer) ... TODO: Optimize by no longer checking for overwrites... (if (row.any? (|>> product.left (n.= artifact_id)) buffer) (phase.except ..cannot_overwrite_output [artifact_id]) - (extension.update (set@ #buffer (#.Some (row.add [artifact_id custom code] buffer))))) + (extension.update (with@ #buffer (#.Some (row.suffix [artifact_id custom code] buffer))))) #.None (phase.except ..no_buffer_for_saving_code [artifact_id])))) @@ -241,8 +241,8 @@ (All [anchor expression directive] (-> Text (Operation anchor expression directive artifact.ID))) (function (_ (^@ stateE [bundle state])) - (let [[id registry'] (<artifact> name (get@ #registry state))] - (#try.Success [[bundle (set@ #registry registry' state)] + (let [[id registry'] (<artifact> name (value@ #registry state))] + (#try.Success [[bundle (with@ #registry registry' state)] id]))))] [learn artifact.definition] @@ -267,11 +267,11 @@ (let [[_module _name] name] (do try.monad [module_id (archive.id _module archive) - registry (if (text\= (get@ #module state) _module) - (#try.Success (get@ #registry state)) + registry (if (text\= (value@ #module state) _module) + (#try.Success (value@ #registry state)) (do try.monad [[descriptor document] (archive.find _module archive)] - (#try.Success (get@ #descriptor.registry descriptor))))] + (#try.Success (value@ #descriptor.registry descriptor))))] (case (artifact.remember _name registry) #.None (exception.except ..unknown_definition [name (artifact.definitions registry)]) @@ -293,13 +293,13 @@ (All [anchor expression directive] (-> Archive (Operation anchor expression directive Context))) (function (_ (^@ stateE [bundle state])) - (case (get@ #context state) + (case (value@ #context state) #.None (exception.except ..no_context []) (#.Some id) (do try.monad - [module_id (archive.id (get@ #module state) archive)] + [module_id (archive.id (value@ #module state) archive)] (in [stateE [module_id id]]))))) (def: .public (with_context id body) @@ -309,8 +309,8 @@ (Operation anchor expression directive a))) (function (_ [bundle state]) (do try.monad - [[[bundle' state'] output] (body [bundle (set@ #context (#.Some id) state)])] - (in [[bundle' (set@ #context (get@ #context state) state')] + [[[bundle' state'] output] (body [bundle (with@ #context (#.Some id) state)])] + (in [[bundle' (with@ #context (value@ #context state) state')] output])))) (def: .public (with_new_context archive body) @@ -318,13 +318,13 @@ (-> Archive (Operation anchor expression directive a) (Operation anchor expression directive [Context a]))) (function (_ (^@ stateE [bundle state])) - (let [[id registry'] (artifact.resource (get@ #registry state))] + (let [[id registry'] (artifact.resource (value@ #registry state))] (do try.monad [[[bundle' state'] output] (body [bundle (|> state - (set@ #registry registry') - (set@ #context (#.Some id)))]) - module_id (archive.id (get@ #module state) archive)] - (in [[bundle' (set@ #context (get@ #context state) state')] + (with@ #registry registry') + (with@ #context (#.Some id)))]) + module_id (archive.id (value@ #module state) archive)] + (in [[bundle' (with@ #context (value@ #context state) state')] [[module_id id] output]]))))) @@ -333,5 +333,5 @@ (-> Text (Operation anchor expression directive Any))) (function (_ [bundle state]) (#try.Success [[bundle - (update@ #log (row.add message) state)] + (revised@ #log (row.suffix message) state)] []]))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux index c8cfe9c0e..ee12a8bf0 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux @@ -124,10 +124,10 @@ (compile archive expansion)) _ - (/function.apply compile argsC+ functionT functionA archive functionC))) + (/function.on compile argsC+ functionT functionA archive functionC))) _ - (/function.apply compile argsC+ functionT functionA archive functionC))) + (/function.on compile argsC+ functionT functionA archive functionC))) _ (//.except ..unrecognized_syntax [location.dummy code']))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux index 9463eeb8f..b3642f5f3 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux @@ -193,20 +193,28 @@ [inputT' (simplify_case inputT)] (.case inputT' (#.Product _) - (let [subs (type.flat_tuple inputT') - num_subs (maybe.else (list.size subs) - num_tags) - num_sub_patterns (list.size sub_patterns) - matches (cond (n.< num_subs num_sub_patterns) - (let [[prefix suffix] (list.split_at (dec num_sub_patterns) subs)] - (list.zipped/2 (list\compose prefix (list (type.tuple suffix))) sub_patterns)) - - (n.> num_subs num_sub_patterns) - (let [[prefix suffix] (list.split_at (dec num_subs) sub_patterns)] - (list.zipped/2 subs (list\compose prefix (list (code.tuple suffix))))) - - ... (n.= num_subs num_sub_patterns) - (list.zipped/2 subs sub_patterns))] + (let [matches (loop [types (type.flat_tuple inputT') + patterns sub_patterns + output (: (List [Type Code]) + #.End)] + (.case [types patterns] + [#.End #.End] + output + + [(#.Item headT #.End) (#.Item headP #.End)] + (#.Item [headT headP] output) + + [remainingT (#.Item headP #.End)] + (#.Item [(type.tuple remainingT) headP] output) + + [(#.Item headT #.End) remainingP] + (#.Item [headT (code.tuple remainingP)] output) + + [(#.Item headT tailT) (#.Item headP tailP)] + (recur tailT tailP (#.Item [headT headP] output)) + + _ + (undefined)))] (do ! [[memberP+ thenA] (list\fold (: (All [a] (-> [Type Code] (Operation [(List Pattern) a]) @@ -220,7 +228,7 @@ (do ! [nextA next] (in [(list) nextA])) - (list.reversed matches))] + matches)] (in [(/.pattern/tuple memberP+) thenA]))) @@ -231,7 +239,7 @@ [location (#.Record record)] (do ///.monad [record (//structure.normal record) - [members recordT] (//structure.order record) + [record_size members recordT] (//structure.order record) _ (.case inputT (#.Var _id) (//type.with_env @@ -239,7 +247,7 @@ _ (in []))] - (analyse_pattern (#.Some (list.size members)) inputT [location (#.Tuple members)] next)) + (analyse_pattern (#.Some record_size) inputT [location (#.Tuple members)] next)) [location (#.Tag tag)] (/.with_location location @@ -260,9 +268,9 @@ (n.< num_cases idx)) (do ///.monad [[testP nextA] (if (and (n.> num_cases size_sum) - (n.= (dec num_cases) idx)) + (n.= (-- num_cases) idx)) (analyse_pattern #.None - (type.variant (list.after (dec num_cases) flat_sum)) + (type.variant (list.after (-- num_cases) flat_sum)) (` [(~+ values)]) next) (analyse_pattern #.None caseT (` [(~+ values)]) next))] diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux index 25c85514e..e7efacf3c 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux @@ -146,7 +146,7 @@ (do ////.monad [value_coverage (determine value) .let [idx (if right? - (inc lefts) + (++ lefts) lefts)]] (in (#Variant (if right? (#.Some idx) @@ -256,7 +256,7 @@ casesSF (dictionary.entries casesA))] (in (if (and (or (known_cases? addition_cases) (known_cases? so_far_cases)) - (n.= (inc (n.max addition_cases so_far_cases)) + (n.= (++ (n.max addition_cases so_far_cases)) (dictionary.size casesM)) (list.every? exhaustive? (dictionary.values casesM))) #Exhaustive diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux index 6282980be..0420b7811 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux @@ -10,7 +10,7 @@ ["." text ["%" format (#+ format)]] [collection - ["." list ("#\." functor)]]] + ["." list ("#\." functor monoid)]]] [math [number ["n" nat]]] @@ -204,16 +204,16 @@ base))) ... Turns a record type into the kind of function type suitable for inference. -(def: (record' target originalT inferT) - (-> Nat Type Type (Operation Type)) +(def: (record' record_size target originalT inferT) + (-> Nat Nat Type Type (Operation Type)) (case inferT (#.Named name unnamedT) - (record' target originalT unnamedT) + (record' record_size target originalT unnamedT) (^template [<tag>] [(<tag> env bodyT) (do ///.monad - [bodyT+ (record' (n.+ 2 target) originalT bodyT)] + [bodyT+ (record' record_size (n.+ 2 target) originalT bodyT)] (in (<tag> env bodyT+)))]) ([#.UnivQ] [#.ExQ]) @@ -221,22 +221,23 @@ (#.Apply inputT funcT) (case (type.applied (list inputT) funcT) (#.Some outputT) - (record' target originalT outputT) + (record' record_size target originalT outputT) #.None (/.except ..invalid_type_application inferT)) (#.Product _) - (///\in (|> inferT - (type.function (type.flat_tuple inferT)) - (substitute_bound target originalT))) + (let [[lefts right] (list.split_at (-- record_size) (type.flat_tuple inferT))] + (///\in (|> inferT + (type.function (list\compose lefts (list (type.tuple right)))) + (substitute_bound target originalT)))) _ (/.except ..not_a_record_type inferT))) -(def: .public (record inferT) - (-> Type (Operation Type)) - (record' (n.- 2 0) inferT inferT)) +(def: .public (record record_size inferT) + (-> Nat Type (Operation Type)) + (record' record_size (n.- 2 0) inferT inferT)) ... Turns a variant type into the kind of function type suitable for inference. (def: .public (variant tag expected_size inferT) @@ -252,7 +253,7 @@ (^template [<tag>] [(<tag> env bodyT) (do ///.monad - [bodyT+ (recur (inc depth) bodyT)] + [bodyT+ (recur (++ depth) bodyT)] (in (<tag> env bodyT+)))]) ([#.UnivQ] [#.ExQ]) @@ -260,7 +261,7 @@ (#.Sum _) (let [cases (type.flat_variant currentT) actual_size (list.size cases) - boundary (dec expected_size)] + boundary (-- expected_size)] (cond (or (n.= expected_size actual_size) (and (n.> expected_size actual_size) (n.< boundary tag))) @@ -268,7 +269,7 @@ (#.Some caseT) (///\in (if (n.= 0 depth) (type.function (list caseT) currentT) - (let [replace' (replace (|> depth dec (n.* 2)) inferT)] + (let [replace' (replace (|> depth -- (n.* 2)) inferT)] (type.function (list (replace' caseT)) (replace' currentT))))) @@ -282,7 +283,7 @@ (let [caseT (type.variant (list.after boundary cases))] (///\in (if (n.= 0 depth) (type.function (list caseT) currentT) - (let [replace' (replace (|> depth dec (n.* 2)) inferT)] + (let [replace' (replace (|> depth -- (n.* 2)) inferT)] (type.function (list (replace' caseT)) (replace' currentT)))))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/module.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/module.lux index d5e2fd691..14e08a4c0 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/module.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/module.lux @@ -84,12 +84,12 @@ (do ///.monad [self_name meta.current_module_name self meta.current_module] - (case (get@ #.module_annotations self) + (case (value@ #.module_annotations self) #.None (function (_ state) - (#try.Success [(update@ #.modules - (plist.has self_name (set@ #.module_annotations (#.Some annotations) self)) - state) + (#try.Success [(revised@ #.modules + (plist.has self_name (with@ #.module_annotations (#.Some annotations) self)) + state) []])) (#.Some old) @@ -101,13 +101,13 @@ (do ///.monad [self_name meta.current_module_name] (function (_ state) - (#try.Success [(update@ #.modules - (plist.revised self_name (update@ #.imports (function (_ current) - (if (list.any? (text\= module) - current) - current - (#.Item module current))))) - state) + (#try.Success [(revised@ #.modules + (plist.revised self_name (revised@ #.imports (function (_ current) + (if (list.any? (text\= module) + current) + current + (#.Item module current))))) + state) []]))))) (def: .public (alias alias module) @@ -116,10 +116,10 @@ (do ///.monad [self_name meta.current_module_name] (function (_ state) - (#try.Success [(update@ #.modules - (plist.revised self_name (update@ #.module_aliases (: (-> (List [Text Text]) (List [Text Text])) - (|>> (#.Item [alias module]))))) - state) + (#try.Success [(revised@ #.modules + (plist.revised self_name (revised@ #.module_aliases (: (-> (List [Text Text]) (List [Text Text])) + (|>> (#.Item [alias module]))))) + state) []]))))) (def: .public (exists? module) @@ -127,7 +127,7 @@ (///extension.lifted (function (_ state) (|> state - (get@ #.modules) + (value@ #.modules) (plist.value module) (case> (#.Some _) #1 #.None #0) [state] #try.Success)))) @@ -139,15 +139,15 @@ [self_name meta.current_module_name self meta.current_module] (function (_ state) - (case (plist.value name (get@ #.definitions self)) + (case (plist.value name (value@ #.definitions self)) #.None - (#try.Success [(update@ #.modules - (plist.has self_name - (update@ #.definitions - (: (-> (List [Text Global]) (List [Text Global])) - (|>> (#.Item [name definition]))) - self)) - state) + (#try.Success [(revised@ #.modules + (plist.has self_name + (revised@ #.definitions + (: (-> (List [Text Global]) (List [Text Global])) + (|>> (#.Item [name definition]))) + self)) + state) []]) (#.Some already_existing) @@ -157,9 +157,9 @@ (-> Nat Text (Operation Any)) (///extension.lifted (function (_ state) - (#try.Success [(update@ #.modules - (plist.has name (..empty hash)) - state) + (#try.Success [(revised@ #.modules + (plist.has name (..empty hash)) + state) []])))) (def: .public (with_module hash name action) @@ -176,15 +176,15 @@ (-> Text (Operation Any)) (///extension.lifted (function (_ state) - (case (|> state (get@ #.modules) (plist.value module_name)) + (case (|> state (value@ #.modules) (plist.value module_name)) (#.Some module) - (let [active? (case (get@ #.module_state module) + (let [active? (case (value@ #.module_state module) #.Active #1 _ #0)] (if active? - (#try.Success [(update@ #.modules - (plist.has module_name (set@ #.module_state <tag> module)) - state) + (#try.Success [(revised@ #.modules + (plist.has module_name (with@ #.module_state <tag> module)) + state) []]) ((/.except' can_only_change_state_of_active_module [module_name <tag>]) state))) @@ -196,10 +196,10 @@ (-> Text (Operation Bit)) (///extension.lifted (function (_ state) - (case (|> state (get@ #.modules) (plist.value module_name)) + (case (|> state (value@ #.modules) (plist.value module_name)) (#.Some module) (#try.Success [state - (case (get@ #.module_state module) + (case (value@ #.module_state module) <tag> #1 _ #0)]) @@ -216,9 +216,9 @@ (-> Text (Operation <type>)) (///extension.lifted (function (_ state) - (case (|> state (get@ #.modules) (plist.value module_name)) + (case (|> state (value@ #.modules) (plist.value module_name)) (#.Some module) - (#try.Success [state (get@ <tag> module)]) + (#try.Success [state (value@ <tag> module)]) #.None ((/.except' unknown_module module_name) state)))))] @@ -258,18 +258,18 @@ (text\= self_name type_module))] (///extension.lifted (function (_ state) - (case (|> state (get@ #.modules) (plist.value self_name)) + (case (|> state (value@ #.modules) (plist.value self_name)) (#.Some module) (let [namespaced_tags (list\map (|>> [self_name]) tags)] - (#try.Success [(update@ #.modules - (plist.revised self_name - (|>> (update@ #.tags (function (_ tag_bindings) - (list\fold (function (_ [idx tag] table) - (plist.has tag [idx namespaced_tags exported? type] table)) - tag_bindings - (list.enumeration tags)))) - (update@ #.types (plist.has type_name [namespaced_tags exported? type])))) - state) + (#try.Success [(revised@ #.modules + (plist.revised self_name + (|>> (revised@ #.tags (function (_ tag_bindings) + (list\fold (function (_ [idx tag] table) + (plist.has tag [idx namespaced_tags exported? type] table)) + tag_bindings + (list.enumeration tags)))) + (revised@ #.types (plist.has type_name [namespaced_tags exported? type])))) + state) []])) #.None ((/.except' unknown_module self_name) state)))))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/scope.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/scope.lux index 052173d1f..44d3b7deb 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/scope.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/scope.lux @@ -32,13 +32,13 @@ (def: (local? name scope) (-> Text Scope Bit) (|> scope - (get@ [#.locals #.mappings]) + (value@ [#.locals #.mappings]) (plist.contains? name))) (def: (local name scope) (-> Text Scope (Maybe [Type Variable])) (|> scope - (get@ [#.locals #.mappings]) + (value@ [#.locals #.mappings]) (plist.value name) (maybe\map (function (_ [type value]) [type (#variable.Local value)])))) @@ -46,18 +46,18 @@ (def: (captured? name scope) (-> Text Scope Bit) (|> scope - (get@ [#.captured #.mappings]) + (value@ [#.captured #.mappings]) (plist.contains? name))) (def: (captured name scope) (-> Text Scope (Maybe [Type Variable])) (loop [idx 0 - mappings (get@ [#.captured #.mappings] scope)] + mappings (value@ [#.captured #.mappings] scope)] (case mappings (#.Item [_name [_source_type _source_ref]] mappings') (if (text\= name _name) (#.Some [_source_type (#variable.Foreign idx)]) - (recur (inc idx) mappings')) + (recur (++ idx) mappings')) #.End #.None))) @@ -81,7 +81,7 @@ (///extension.lifted (function (_ state) (let [[inner outer] (|> state - (get@ #.scopes) + (value@ #.scopes) (list.split_when (|>> (reference? name))))] (case outer #.End @@ -92,17 +92,17 @@ (..reference name top_outer)) [ref inner'] (list\fold (: (-> Scope [Variable (List Scope)] [Variable (List Scope)]) (function (_ scope ref+inner) - [(#variable.Foreign (get@ [#.captured #.counter] scope)) - (#.Item (update@ #.captured - (: (-> Foreign Foreign) - (|>> (update@ #.counter inc) - (update@ #.mappings (plist.has name [ref_type (product.left ref+inner)])))) - scope) + [(#variable.Foreign (value@ [#.captured #.counter] scope)) + (#.Item (revised@ #.captured + (: (-> Foreign Foreign) + (|>> (revised@ #.counter ++) + (revised@ #.mappings (plist.has name [ref_type (product.left ref+inner)])))) + scope) (product.right ref+inner))])) [init_ref #.End] (list.reversed inner)) scopes (list\compose inner' outer)] - (#.Right [(set@ #.scopes scopes state) + (#.Right [(with@ #.scopes scopes state) (#.Some [ref_type ref])])) ))))) @@ -112,23 +112,23 @@ (def: .public (with_local [name type] action) (All [a] (-> [Text Type] (Operation a) (Operation a))) (function (_ [bundle state]) - (case (get@ #.scopes state) + (case (value@ #.scopes state) (#.Item head tail) - (let [old_mappings (get@ [#.locals #.mappings] head) - new_var_id (get@ [#.locals #.counter] head) - new_head (update@ #.locals - (: (-> Local Local) - (|>> (update@ #.counter inc) - (update@ #.mappings (plist.has name [type new_var_id])))) - head)] - (case (///.result' [bundle (set@ #.scopes (#.Item new_head tail) state)] + (let [old_mappings (value@ [#.locals #.mappings] head) + new_var_id (value@ [#.locals #.counter] head) + new_head (revised@ #.locals + (: (-> Local Local) + (|>> (revised@ #.counter ++) + (revised@ #.mappings (plist.has name [type new_var_id])))) + head)] + (case (///.result' [bundle (with@ #.scopes (#.Item new_head tail) state)] action) (#try.Success [[bundle' state'] output]) - (case (get@ #.scopes state') + (case (value@ #.scopes state') (#.Item head' tail') - (let [scopes' (#.Item (set@ #.locals (get@ #.locals head) head') + (let [scopes' (#.Item (with@ #.locals (value@ #.locals head) head') tail')] - (#try.Success [[bundle' (set@ #.scopes scopes' state')] + (#try.Success [[bundle' (with@ #.scopes scopes' state')] output])) _ @@ -161,19 +161,19 @@ (def: .public (with_scope name action) (All [a] (-> Text (Operation a) (Operation a))) (function (_ [bundle state]) - (let [parent_name (case (get@ #.scopes state) + (let [parent_name (case (value@ #.scopes state) #.End (list) (#.Item top _) - (get@ #.name top))] - (case (action [bundle (update@ #.scopes - (|>> (#.Item (scope parent_name name))) - state)]) + (value@ #.name top))] + (case (action [bundle (revised@ #.scopes + (|>> (#.Item (scope parent_name name))) + state)]) (#try.Success [[bundle' state'] output]) - (#try.Success [[bundle' (update@ #.scopes - (|>> list.tail (maybe.else (list))) - state')] + (#try.Success [[bundle' (revised@ #.scopes + (|>> list.tail (maybe.else (list))) + state')] output]) (#try.Failure error) @@ -185,9 +185,9 @@ (Operation Register) (///extension.lifted (function (_ state) - (case (get@ #.scopes state) + (case (value@ #.scopes state) (#.Item top _) - (#try.Success [state (get@ [#.locals #.counter] top)]) + (#try.Success [state (value@ [#.locals #.counter] top)]) #.End (exception.except ..cannot_get_next_reference_when_there_is_no_scope []))))) @@ -204,5 +204,5 @@ (def: .public (environment scope) (-> Scope (List Variable)) (|> scope - (get@ [#.captured #.mappings]) + (value@ [#.captured #.mappings]) (list\map (function (_ [_ [_ ref]]) (ref_variable ref))))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux index 56924a102..fe296c83e 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux @@ -299,11 +299,11 @@ ... re-implementing the same functionality for records makes no sense. ... Records, thus, get transformed into tuples by ordering the elements. (def: .public (order record) - (-> (List [Name Code]) (Operation [(List Code) Type])) + (-> (List [Name Code]) (Operation [Nat (List Code) Type])) (case record - ... empty_record = empty_tuple = unit = [] + ... empty_record = empty_tuple = unit/any = [] #.End - (\ ///.monad in [(list) Any]) + (\ ///.monad in [0 (list) Any]) (#.Item [head_k head_v] _) (do {! ///.monad} @@ -334,7 +334,7 @@ .let [ordered_tuple (list\map (function (_ idx) (maybe.trusted (dictionary.value idx idx->val))) tuple_range)]] - (in [ordered_tuple recordT])) + (in [size_ts ordered_tuple recordT])) )) (def: .public (record archive analyse members) @@ -349,12 +349,12 @@ _ (do {! ///.monad} [members (normal members) - [membersC recordT] (order members) + [record_size membersC recordT] (..order members) expectedT (///extension.lifted meta.expected_type)] (case expectedT (#.Var _) (do ! - [inferenceT (//inference.record recordT) + [inferenceT (//inference.record record_size recordT) [inferredT membersA] (//inference.general archive analyse inferenceT membersC)] (in (/.tuple membersA))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/type.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/type.lux index ed980b1e6..f1ffa9026 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/type.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/type.lux @@ -18,15 +18,15 @@ (def: .public (with_type expected) (All [a] (-> Type (Operation a) (Operation a))) - (///extension.localized (get@ #.expected) (set@ #.expected) + (///extension.localized (value@ #.expected) (with@ #.expected) (function.constant (#.Some expected)))) (def: .public (with_env action) (All [a] (-> (Check a) (Operation a))) (function (_ (^@ stateE [bundle state])) - (case (action (get@ #.type_context state)) + (case (action (value@ #.type_context state)) (#try.Success [context' output]) - (#try.Success [[bundle (set@ #.type_context context' state)] + (#try.Success [[bundle (with@ #.type_context context' state)] output]) (#try.Failure error) @@ -34,7 +34,7 @@ (def: .public with_fresh_env (All [a] (-> (Operation a) (Operation a))) - (///extension.localized (get@ #.type_context) (set@ #.type_context) + (///extension.localized (value@ #.type_context) (with@ #.type_context) (function.constant check.fresh_context))) (def: .public (infer actualT) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/directive.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/directive.lux index 81fc21caa..cc34e04cf 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/directive.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/directive.lux @@ -68,7 +68,7 @@ (case expansion (^ (list& <lux_def_module> referrals)) (|> (recur archive <lux_def_module>) - (\ ! map (update@ #/.referrals (list\compose referrals)))) + (\ ! map (revised@ #/.referrals (list\compose referrals)))) _ (|> expansion diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux index aa1730655..508242cd8 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux @@ -1140,24 +1140,22 @@ phase.lifted)] (in (and (java/lang/Object::equals class (java/lang/reflect/Constructor::getDeclaringClass constructor)) (n.= (list.size inputsJT) (list.size parameters)) - (list\fold (function (_ [expectedJC actualJC] prev) - (and prev - (jvm\= expectedJC (: (Type Value) - (case (jvm_parser.var? actualJC) - (#.Some name) - (|> aliasing - (dictionary.value name) - (maybe.else name) - jvm.var) - - #.None - actualJC))))) - true - (list.zipped/2 parameters inputsJT)))))) + (list.every? (function (_ [expectedJC actualJC]) + (jvm\= expectedJC (: (Type Value) + (case (jvm_parser.var? actualJC) + (#.Some name) + (|> aliasing + (dictionary.value name) + (maybe.else name) + jvm.var) + + #.None + actualJC)))) + (list.zipped/2 parameters inputsJT)))))) (def: index_parameter (-> Nat .Type) - (|>> (n.* 2) inc #.Parameter)) + (|>> (n.* 2) ++ #.Parameter)) (def: (jvm_type_var_mapping owner_tvars method_tvars) (-> (List Text) (List Text) [(List .Type) Mapping]) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/directive/jvm.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/directive/jvm.lux index 61f4e3763..0242d94b6 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/directive/jvm.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/directive/jvm.lux @@ -279,9 +279,9 @@ super_classT super_interfaceT+)] state (extension.lifted phase.get_state) - .let [analyse (get@ [#directive.analysis #directive.phase] state) - synthesize (get@ [#directive.synthesis #directive.phase] state) - generate (get@ [#directive.generation #directive.phase] state)] + .let [analyse (value@ [#directive.analysis #directive.phase] state) + synthesize (value@ [#directive.synthesis #directive.phase] state) + generate (value@ [#directive.generation #directive.phase] state)] methods (monad.map ! (..method_definition [mapping selfT] [analyse synthesize generate]) methods) ... _ (directive.lifted_generation diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/directive/lux.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/directive/lux.lux index 604292cdd..329c79611 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/directive/lux.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/directive/lux.lux @@ -63,7 +63,7 @@ (def: (context [module_id artifact_id]) (-> Context Context) ... TODO: Find a better way that doesn't rely on clever tricks. - [module_id (n.- (inc artifact_id) 0)]) + [module_id (n.- (++ artifact_id) 0)]) ... TODO: Inline "evaluate!'" into "evaluate!" ASAP (def: (evaluate!' archive generate code//type codeS) @@ -87,9 +87,9 @@ (-> Archive Type Code (Operation anchor expression directive [Type expression Any]))) (do phase.monad [state (///.lifted phase.get_state) - .let [analyse (get@ [#/////directive.analysis #/////directive.phase] state) - synthesize (get@ [#/////directive.synthesis #/////directive.phase] state) - generate (get@ [#/////directive.generation #/////directive.phase] state)] + .let [analyse (value@ [#/////directive.analysis #/////directive.phase] state) + synthesize (value@ [#/////directive.synthesis #/////directive.phase] state) + generate (value@ [#/////directive.generation #/////directive.phase] state)] [_ codeA] (/////directive.lifted_analysis (/////analysis.with_scope (typeA.with_fresh_env @@ -123,9 +123,9 @@ (Operation anchor expression directive [Type expression Any]))) (do {! phase.monad} [state (///.lifted phase.get_state) - .let [analyse (get@ [#/////directive.analysis #/////directive.phase] state) - synthesize (get@ [#/////directive.synthesis #/////directive.phase] state) - generate (get@ [#/////directive.generation #/////directive.phase] state)] + .let [analyse (value@ [#/////directive.analysis #/////directive.phase] state) + synthesize (value@ [#/////directive.synthesis #/////directive.phase] state) + generate (value@ [#/////directive.generation #/////directive.phase] state)] [_ code//type codeA] (/////directive.lifted_analysis (/////analysis.with_scope (typeA.with_fresh_env @@ -175,9 +175,9 @@ (Operation anchor expression directive [expression Any]))) (do phase.monad [state (///.lifted phase.get_state) - .let [analyse (get@ [#/////directive.analysis #/////directive.phase] state) - synthesize (get@ [#/////directive.synthesis #/////directive.phase] state) - generate (get@ [#/////directive.generation #/////directive.phase] state)] + .let [analyse (value@ [#/////directive.analysis #/////directive.phase] state) + synthesize (value@ [#/////directive.synthesis #/////directive.phase] state) + generate (value@ [#/////directive.generation #/////directive.phase] state)] [_ codeA] (/////directive.lifted_analysis (/////analysis.with_scope (typeA.with_fresh_env @@ -199,15 +199,15 @@ (do phase.monad [[bundle state] phase.get_state .let [eval (/////analysis/evaluation.evaluator expander - (get@ [#/////directive.synthesis #/////directive.state] state) - (get@ [#/////directive.generation #/////directive.state] state) - (get@ [#/////directive.generation #/////directive.phase] state))]] + (value@ [#/////directive.synthesis #/////directive.state] state) + (value@ [#/////directive.generation #/////directive.state] state) + (value@ [#/////directive.generation #/////directive.phase] state))]] (phase.set_state [bundle - (update@ [#/////directive.analysis #/////directive.state] - (: (-> /////analysis.State+ /////analysis.State+) - (|>> product.right - [(///analysis.bundle eval host_analysis)])) - state)]))) + (revised@ [#/////directive.analysis #/////directive.state] + (: (-> /////analysis.State+ /////analysis.State+) + (|>> product.right + [(///analysis.bundle eval host_analysis)])) + state)]))) (def: (announce_definition! short type) (All [anchor expression directive] @@ -310,8 +310,8 @@ (function (_ extension_name phase archive [alias def_name]) (do phase.monad [_ (///.lifted - (phase.sub [(get@ [#/////directive.analysis #/////directive.state]) - (set@ [#/////directive.analysis #/////directive.state])] + (phase.sub [(value@ [#/////directive.analysis #/////directive.state]) + (with@ [#/////directive.analysis #/////directive.state])] (define_alias alias def_name)))] (in /////directive.no_requirements)))])) @@ -405,9 +405,9 @@ (^ (list programC)) (do phase.monad [state (///.lifted phase.get_state) - .let [analyse (get@ [#/////directive.analysis #/////directive.phase] state) - synthesize (get@ [#/////directive.synthesis #/////directive.phase] state) - generate (get@ [#/////directive.generation #/////directive.phase] state)] + .let [analyse (value@ [#/////directive.analysis #/////directive.phase] state) + synthesize (value@ [#/////directive.synthesis #/////directive.phase] state) + generate (value@ [#/////directive.generation #/////directive.phase] state)] programS (prepare_program archive analyse synthesize programC) current_module (/////directive.lifted_analysis (///.lifted meta.current_module_name)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/common.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/common.lux index a8caf13bf..e18b6d356 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/common.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/common.lux @@ -128,7 +128,7 @@ list\join) conditionalsG (|> conditionalsG+ (list\map product.right) - (monad.seq _.monad))]] + (monad.all _.monad))]] (in (do _.monad [@else _.new_label] ($_ _.composite diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux index a749fb6cd..be90b8876 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux @@ -948,7 +948,7 @@ (monad.map _.monad (.function (_ register) ($_ _.composite (_.aload 0) - (_.aload (inc register)) + (_.aload (++ register)) (_.putfield class (///reference.foreign_name register) $Object)))))] (method.method method.public "<init>" (anonymous_init_method env) (list) @@ -966,7 +966,7 @@ (in ($_ _.composite (_.new class) _.dup - (monad.seq _.monad captureG+) + (monad.all _.monad captureG+) (_.invokespecial class "<init>" (anonymous_init_method env)))))) (def: (returnG returnT) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/php/common.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/php/common.lux index 45d6873da..02ddfbd71 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/php/common.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/php/common.lux @@ -84,7 +84,7 @@ .let [foreigns (|> conditionals (list\map (|>> product.right synthesis.path/then //case.dependencies)) (list& (//case.dependencies (synthesis.path/then else))) - list.joined + list.together (set.of_list _.hash) set.list) @expression (_.constant (reference.artifact [context_module context_artifact])) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/python/common.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/python/common.lux index f683c9b9a..c531d05d9 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/python/common.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/python/common.lux @@ -7,7 +7,7 @@ ["." function] ["." try] ["<>" parser - ["<s>" synthesis (#+ Parser)]]] + ["<.>" synthesis (#+ Parser)]]] [data ["." product] ["." text @@ -41,7 +41,7 @@ (-> Text (Generator s))] Handler)) (function (_ extension_name phase archive input) - (case (<s>.result parser input) + (case (<synthesis>.result parser input) (#try.Success input') (handler extension_name phase archive input') @@ -51,11 +51,11 @@ ... TODO: Get rid of this ASAP (def: lux::syntax_char_case! (..custom [($_ <>.and - <s>.any - <s>.any - (<>.some (<s>.tuple ($_ <>.and - (<s>.tuple (<>.many <s>.i64)) - <s>.any)))) + <synthesis>.any + <synthesis>.any + (<>.some (<synthesis>.tuple ($_ <>.and + (<synthesis>.tuple (<>.many <synthesis>.i64)) + <synthesis>.any)))) (function (_ extension_name phase archive [input else conditionals]) (do {! /////.monad} [inputG (phase archive input) @@ -101,9 +101,9 @@ (/.install "and" (binary (product.uncurried //runtime.i64::and))) (/.install "or" (binary (product.uncurried //runtime.i64::or))) (/.install "xor" (binary (product.uncurried //runtime.i64::xor))) - (/.install "left-shift" (binary (product.uncurried //runtime.i64::left_shift))) - (/.install "right-shift" (binary (product.uncurried //runtime.i64::right_shift))) - + (/.install "left-shift" (binary (product.uncurried //runtime.i64::left_shifted))) + (/.install "right-shift" (binary (product.uncurried //runtime.i64::right_shifted))) + (/.install "<" (binary (product.uncurried _.<))) (/.install "=" (binary (product.uncurried _.=))) (/.install "+" (binary (product.uncurried (..capped _.+)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/case.lux index 7bc4f46df..fae91850c 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/case.lux @@ -124,7 +124,7 @@ (list))))))] [left_choice _.nil (<|)] - [right_choice (_.string "") inc] + [right_choice (_.string "") ++] ) (def: (alternation @otherwise pre! post!) @@ -248,7 +248,7 @@ pattern_matching! (pattern_matching $output expression archive pathP) .let [storage (|> pathP ////synthesis/case.storage - (get@ #////synthesis/case.bindings) + (value@ #////synthesis/case.bindings) set.list (list\map (function (_ register) [(..register register) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/function.lux index 917ab8503..41faa95b6 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/function.lux @@ -56,7 +56,7 @@ (_.funcall/+ [(_.function/1 @closure) inits])))))) (def: input - (|>> inc //case.register)) + (|>> ++ //case.register)) (def: .public (function expression archive [environment arity bodyS]) (Generator (Abstraction Synthesis)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/runtime.lux index db8c9b18e..7eca077bf 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/runtime.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- Location inc) + [lux (#- Location) ["." meta] [abstract ["." monad (#+ do)]] @@ -90,13 +90,13 @@ (syntax: .public (with_vars [vars (<code>.tuple (<>.some <code>.local_identifier)) body <code>.any]) (do {! meta.monad} - [ids (monad.seq ! (list.repeated (list.size vars) meta.seed))] + [ids (monad.all ! (list.repeated (list.size vars) meta.seed))] (in (list (` (let [(~+ (|> vars (list.zipped/2 ids) (list\map (function (_ [id var]) (list (code.local_identifier var) (` (_.var (~ (code.text (format "v" (%.nat id))))))))) - list.joined))] + list.together))] (~ body))))))) (syntax: (runtime: [declaration (<>.or <code>.local_identifier diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/structure.lux index df957a3cd..6755b8f33 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/common_lisp/structure.lux @@ -31,7 +31,7 @@ (def: .public (variant expression archive [lefts right? valueS]) (Generator (Variant Synthesis)) (let [tag (if right? - (inc lefts) + (++ lefts) lefts)] (///////phase\map (|>> [tag right?] //runtime.variant) (expression archive valueS)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/extension.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/extension.lux index 6a5f40ef7..3802776c8 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/extension.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/extension.lux @@ -36,7 +36,7 @@ type <code>.any]) (with_identifiers [g!_ g!extension g!name g!phase g!archive g!inputs g!of g!anchor g!expression g!directive] (do {! meta.monad} - [g!input+ (monad.seq ! (list.repeated arity (macro.identifier "input")))] + [g!input+ (monad.all ! (list.repeated arity (macro.identifier "input")))] (in (list (` (def: .public ((~ (code.local_identifier name)) (~ g!extension)) (All [(~ g!anchor) (~ g!expression) (~ g!directive)] (-> ((~ type) (~ g!expression)) @@ -48,7 +48,7 @@ [(~+ (|> g!input+ (list\map (function (_ g!input) (list g!input (` ((~ g!phase) (~ g!archive) (~ g!input)))))) - list.joined))] + list.together))] ((~' in) ((~ g!extension) [(~+ g!input+)]))) (~' _) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/case.lux index b89ca3c5a..9b0431808 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/case.lux @@ -144,7 +144,7 @@ (push_cursor! @temp)))))] [left_choice _.null (<|)] - [right_choice (_.string "") inc] + [right_choice (_.string "") ++] ) (def: (alternation pre! post!) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/function.lux index cccb72dd5..fdfc768a0 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/function.lux @@ -56,7 +56,7 @@ (_.var "curried")) (def: input - (|>> inc //case.register)) + (|>> ++ //case.register)) (def: @@arguments (_.var "arguments")) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/runtime.lux index 57916d38a..368c69bb0 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/runtime.lux @@ -68,7 +68,7 @@ (def: .public low (-> (I64 Any) (I64 Any)) - (let [mask (dec (i64.left_shifted 32 1))] + (let [mask (-- (i64.left_shifted 32 1))] (|>> (i64.and mask)))) (def: .public unit @@ -88,13 +88,13 @@ (syntax: .public (with_vars [vars (<code>.tuple (<>.some <code>.local_identifier)) body <code>.any]) (do {! meta.monad} - [ids (monad.seq ! (list.repeated (list.size vars) meta.seed))] + [ids (monad.all ! (list.repeated (list.size vars) meta.seed))] (in (list (` (let [(~+ (|> vars (list.zipped/2 ids) (list\map (function (_ [id var]) (list (code.local_identifier var) (` (_.var (~ (code.text (format "v" (%.nat id))))))))) - list.joined))] + list.together))] (~ body))))))) (syntax: (runtime: [declaration (<>.or <code>.local_identifier diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/structure.lux index ebaaa7f49..6253b38b5 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/js/structure.lux @@ -31,7 +31,7 @@ (def: .public (variant generate archive [lefts right? valueS]) (Generator (Variant Synthesis)) (let [tag (if right? - (inc lefts) + (++ lefts) lefts)] (///////phase\map (//runtime.variant (_.i32 (.int tag)) (//runtime.flag right?)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/case.lux index aebb30404..417f74d2d 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/case.lux @@ -174,7 +174,7 @@ (#synthesis.Alt leftP rightP) (do phase.monad [@alt_else //runtime.forge_label - left! (path' (inc stack_depth) @alt_else @end phase archive leftP) + left! (path' (++ stack_depth) @alt_else @end phase archive leftP) right! (path' stack_depth @else @end phase archive rightP)] (in ($_ _.composite _.dup diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function.lux index f3938db06..5eafc6556 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function.lux @@ -74,7 +74,7 @@ (if (arity.multiary? arity) (|> (n.min arity /arity.maximum) list.indices - (list\map (|>> inc (/apply.method classT environment arity @begin body))) + (list\map (|>> ++ (/apply.method classT environment arity @begin body))) (list& (/implementation.method arity @begin body))) (list (/implementation.method' //runtime.apply::name arity @begin body)))))] (do phase.monad @@ -129,7 +129,7 @@ (function (_ batchG) ($_ _.composite (_.checkcast /abstract.class) - (monad.seq _.monad batchG) + (monad.all _.monad batchG) (_.invokevirtual /abstract.class //runtime.apply::name (//runtime.apply::type (list.size batchG))) )))) )))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/field/variable/partial/count.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/field/variable/count.lux index 30f27def6..1ec854f71 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/field/variable/partial/count.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/field/variable/count.lux @@ -6,11 +6,11 @@ [target [jvm ["_" bytecode (#+ Bytecode)] + ["." type] [encoding [name (#+ External)] - ["." signed]] - ["." type]]]]] - ["." ///// #_ + ["." signed]]]]]] + ["." //// #_ ["#." abstract]]) (def: .public field "partials") @@ -30,5 +30,5 @@ (Bytecode Any) ($_ _.composite ..this - (_.getfield /////abstract.class ..field ..type) + (_.getfield ////abstract.class ..field ..type) )) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/field/variable/partial.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/field/variable/partial.lux index 57d285e8a..19dc23779 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/field/variable/partial.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/field/variable/partial.lux @@ -35,7 +35,7 @@ ($_ _.composite (|> _.aconst_null (list.repeated amount) - (monad.seq _.monad)) + (monad.all _.monad)) (_\in []))) (def: .public (get class register) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/apply.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/apply.lux index da3292be8..1addefe99 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/apply.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/apply.lux @@ -79,7 +79,7 @@ (def: .public (method class environment function_arity @begin body apply_arity) (-> (Type Class) (Environment Synthesis) Arity Label (Bytecode Any) Arity (Resource Method)) - (let [num_partials (dec function_arity) + (let [num_partials (-- function_arity) over_extent (i.- (.int apply_arity) (.int function_arity))] (method.method //.modifier ////runtime.apply::name @@ -95,15 +95,15 @@ [@default _.new_label @labelsH _.new_label @labelsT (|> _.new_label - (list.repeated (dec num_partials)) - (monad.seq _.monad)) + (list.repeated (-- num_partials)) + (monad.all _.monad)) .let [cases (|> (list\compose (#.Item [@labelsH @labelsT]) (list @default)) list.enumeration (list\map (function (_ [stage @case]) (let [current_partials (|> (list.indices stage) (list\map (///partial.get class)) - (monad.seq _.monad)) + (monad.all _.monad)) already_partial? (n.> 0 stage) exact_match? (i.= over_extent (.int stage)) has_more_than_necessary? (i.> over_extent (.int stage))] @@ -135,10 +135,10 @@ ... (i.< over_extent (.int stage)) (let [current_environment (|> (list.indices (list.size environment)) (list\map (///foreign.get class)) - (monad.seq _.monad)) + (monad.all _.monad)) missing_partials (|> _.aconst_null (list.repeated (|> num_partials (n.- apply_arity) (n.- stage))) - (monad.seq _.monad))] + (monad.all _.monad))] ($_ _.composite (_.new class) _.dup @@ -150,7 +150,7 @@ missing_partials (_.invokevirtual class //init.name (//init.type environment function_arity)) _.areturn))))))) - (monad.seq _.monad))]] + (monad.all _.monad))]] ($_ _.composite ///partial/count.value (_.tableswitch (try.trusted (signed.s4 +0)) @default [@labelsH @labelsT]) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/init.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/init.lux index cd92f4aca..3c1922063 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/init.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/init.lux @@ -45,7 +45,7 @@ (def: (partials arity) (-> Arity (List (Type Value))) - (list.repeated (dec arity) ////type.value)) + (list.repeated (-- arity) ////type.value)) (def: .public (type environment arity) (-> (Environment Synthesis) Arity (Type category.Method)) @@ -64,7 +64,7 @@ (def: .public (super environment_size arity) (-> Nat Arity (Bytecode Any)) - (let [arity_register (inc environment_size)] + (let [arity_register (++ environment_size)] ($_ _.composite (if (arity.unary? arity) ..no_partials @@ -80,7 +80,7 @@ (list\map (function (_ register) (put register (_.aload (offset register))))) - (monad.seq _.monad))) + (monad.all _.monad))) (def: .public (method class environment arity) (-> (Type Class) (Environment Synthesis) Arity (Resource Method)) @@ -98,5 +98,5 @@ ////reference.this (..super environment_size arity) (store_all environment_size (///foreign.put class) offset_foreign) - (store_all (dec arity) (///partial.put class) offset_partial) + (store_all (-- arity) (///partial.put class) offset_partial) _.return))))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/new.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/new.lux index d153b35e9..c126f0296 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/new.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/function/method/new.lux @@ -47,7 +47,7 @@ ($_ _.composite (_.new class) _.dup - (monad.seq _.monad foreign_setup) + (monad.all _.monad foreign_setup) (///partial.new arity) (_.invokespecial class //init.name (//init.type environment arity)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/loop.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/loop.lux index 6757bc987..9b69ffbae 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/loop.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/loop.lux @@ -64,11 +64,11 @@ ... should be the case. (|> updatesG (list\map product.left) - (monad.seq _.monad)) + (monad.all _.monad)) (|> updatesG list.reversed (list\map product.right) - (monad.seq _.monad)) + (monad.all _.monad)) (_.goto @begin))))) (def: .public (scope translate archive [offset initsS+ iterationS]) @@ -83,7 +83,7 @@ ($_ _.composite initG (_.astore (n.+ offset index))))) - (monad.seq _.monad))]] + (monad.all _.monad))]] (in ($_ _.composite initializationG (_.set_label @begin) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/runtime.lux index f11c871c1..1d414ab77 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/runtime.lux @@ -44,8 +44,7 @@ [constant ["#/." arity]] [variable - [partial - ["#/." count]]]]] + ["#/." count]]]] ["//#" /// #_ [// ["." version] @@ -60,11 +59,14 @@ [io (#+ lux_context)] [archive (#+ Archive)]]]]]]) -(type: .public Byte_Code Binary) +(type: .public Byte_Code + Binary) -(type: .public Definition [Text Byte_Code]) +(type: .public Definition + [Text Byte_Code]) -(type: .public Anchor [Label Register]) +(type: .public Anchor + [Label Register]) (template [<name> <base>] [(type: .public <name> @@ -542,7 +544,7 @@ (def: generate_function (Operation Any) (let [apply::method+ (|> (enum.range n.enum - (inc //function/arity.minimum) + (++ //function/arity.minimum) //function/arity.maximum) (list\map (function (_ arity) (method.method method.public ..apply::name (..apply::type arity) @@ -553,7 +555,7 @@ (monad.map _.monad _.aload))] ($_ _.composite previous_inputs - (_.invokevirtual //function.class ..apply::name (..apply::type (dec arity))) + (_.invokevirtual //function.class ..apply::name (..apply::type (-- arity))) (_.checkcast //function.class) (_.aload arity) (_.invokevirtual //function.class ..apply::name (..apply::type //function/arity.minimum)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux index 062708388..815c4fca0 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux @@ -50,12 +50,12 @@ (in (do {! _.monad} [_ (_.int (.i64 (list.size membersS))) _ (_.anewarray $Object)] - (monad.seq ! membersI)))))) + (monad.all ! membersI)))))) (def: .public (tag lefts right?) (-> Nat Bit (Bytecode Any)) (case (if right? - (.inc lefts) + (.++ lefts) lefts) 0 _.iconst_0 1 _.iconst_1 diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/case.lux index d21adc3ef..ef53de88c 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/case.lux @@ -145,7 +145,7 @@ (..push! @temp)))))] [left_choice _.nil (<|)] - [right_choice (_.string "") inc] + [right_choice (_.string "") ++] ) (def: (alternation pre! post!) @@ -250,7 +250,7 @@ (def: .public dependencies (-> Path (List Var)) (|>> ////synthesis/case.storage - (get@ #////synthesis/case.dependencies) + (value@ #////synthesis/case.dependencies) set.list (list\map (function (_ variable) (.case variable diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/function.lux index 65930fb75..509808d62 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/function.lux @@ -57,7 +57,7 @@ (_.apply/* inits @self)]))) (def: input - (|>> inc //case.register)) + (|>> ++ //case.register)) (def: (@scope function_name) (-> Context Label) @@ -82,7 +82,7 @@ initialize! (list\fold (.function (_ post pre!) ($_ _.then pre! - (_.local/1 (..input post) (_.item (|> post inc .int _.int) @curried)))) + (_.local/1 (..input post) (_.item (|> post ++ .int _.int) @curried)))) initialize_self! (list.indices arity)) pack (|>> (list) _.array) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux index a1c3d7ca2..988274333 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- Location inc) + [lux (#- Location) ["." meta] [abstract ["." monad (#+ do)]] @@ -105,13 +105,13 @@ (syntax: .public (with_vars [vars (<code>.tuple (<>.some <code>.local_identifier)) body <code>.any]) (do {! meta.monad} - [ids (monad.seq ! (list.repeated (list.size vars) meta.seed))] + [ids (monad.all ! (list.repeated (list.size vars) meta.seed))] (in (list (` (let [(~+ (|> vars (list.zipped/2 ids) (list\map (function (_ [id var]) (list (code.local_identifier var) (` (_.var (~ (code.text (format "v" (%.nat id))))))))) - list.joined))] + list.together))] (~ body))))))) (def: module_id diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/structure.lux index 8c78dea65..6bbd167eb 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/structure.lux @@ -31,7 +31,7 @@ (def: .public (variant generate archive [lefts right? valueS]) (Generator (Variant Synthesis)) (let [tag (if right? - (inc lefts) + (++ lefts) lefts)] (///////phase\map (//runtime.variant tag right?) (generate archive valueS)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/case.lux index 04cce603a..28744fe33 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/case.lux @@ -145,7 +145,7 @@ (..push! @temp)))))] [left_choice _.null (<|)] - [right_choice (_.string "") inc] + [right_choice (_.string "") ++] ) (def: (alternation pre! post!) @@ -260,7 +260,7 @@ (def: .public dependencies (-> Path (List Var)) (|>> ////synthesis/case.storage - (get@ #////synthesis/case.dependencies) + (value@ #////synthesis/case.dependencies) set.list (list\map (function (_ variable) (.case variable diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/function.lux index 5cc25a622..175fadfc3 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/function.lux @@ -41,7 +41,7 @@ (|>> (///reference.foreign //reference.system) :expected)) (def: input - (|>> inc //case.register)) + (|>> ++ //case.register)) (def: (@scope function_name) (-> Context Label) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux index 6f69ba6e6..bd36c0785 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/runtime.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- Location inc) + [lux (#- Location) ["." meta] [abstract ["." monad (#+ do)]] @@ -73,13 +73,13 @@ (syntax: .public (with_vars [vars (<code>.tuple (<>.some <code>.local_identifier)) body <code>.any]) (do {! meta.monad} - [ids (monad.seq ! (list.repeated (list.size vars) meta.seed))] + [ids (monad.all ! (list.repeated (list.size vars) meta.seed))] (in (list (` (let [(~+ (|> vars (list.zipped/2 ids) (list\map (function (_ [id var]) (list (code.local_identifier var) (` (_.var (~ (code.text (format "v" (%.nat id))))))))) - list.joined))] + list.together))] (~ body))))))) (def: module_id @@ -342,7 +342,7 @@ (def: .public low (-> (I64 Any) (I64 Any)) - (let [mask (dec (i64.left_shifted 32 1))] + (let [mask (-- (i64.left_shifted 32 1))] (|>> (i64.and mask)))) (runtime: (i64//right_shifted param subject) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/structure.lux index 69979afd6..a7fe22f6d 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/php/structure.lux @@ -36,7 +36,7 @@ (def: .public (variant expression archive [lefts right? valueS]) (Generator (Variant Synthesis)) (let [tag (if right? - (inc lefts) + (++ lefts) lefts)] (///////phase\map (//runtime.variant tag right?) (expression archive valueS)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/case.lux index df2a1a3fc..5d66730d1 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/case.lux @@ -148,7 +148,7 @@ )))] [left_choice _.none (<|)] - [right_choice (_.string "") inc] + [right_choice (_.string "") ++] ) (def: (with_looping in_closure? g!once body!) @@ -298,7 +298,7 @@ (def: .public dependencies (-> Path (List SVar)) (|>> case.storage - (get@ #case.dependencies) + (value@ #case.dependencies) set.list (list\map (function (_ variable) (.case variable diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/function.lux index b1ce3f5c8..eee714ea8 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/function.lux @@ -19,7 +19,7 @@ ["/#" // #_ ["#." reference] ["//#" /// #_ - [analysis (#+ Variant Tuple Environment Abstraction Application Analysis)] + [analysis (#+ Environment Abstraction Application Analysis)] [synthesis (#+ Synthesis)] ["#." generation (#+ Context)] ["//#" /// #_ @@ -64,7 +64,7 @@ (in (_.apply/* @function inits))))) (def: input - (|>> inc //case.register)) + (|>> ++ //case.register)) (def: .public (function statement expression archive [environment arity bodyS]) (-> Phase! (Generator (Abstraction Synthesis))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux index e26aca84a..207b74654 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/runtime.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- inc) + [lux (#- ++) ["." meta] [abstract ["." monad (#+ do)]] @@ -112,13 +112,13 @@ (syntax: .public (with_vars [vars (<code>.tuple (<>.some <code>.local_identifier)) body <code>.any]) (do {! meta.monad} - [ids (monad.seq ! (list.repeated (list.size vars) meta.seed))] + [ids (monad.all ! (list.repeated (list.size vars) meta.seed))] (in (list (` (let [(~+ (|> vars (list.zipped/2 ids) (list\map (function (_ [id var]) (list (code.local_identifier var) (` (_.var (~ (code.text (format "v" (%.nat id))))))))) - list.joined))] + list.together))] (~ body))))))) (syntax: (runtime: [declaration (<>.or <code>.local_identifier @@ -395,7 +395,7 @@ ..none (..some (..i64::64 idx))))))) -(def: inc +(def: ++ (|>> (_.+ (_.int +1)))) (def: (within? top value) @@ -408,7 +408,7 @@ (runtime: (text::char idx text) (_.if (|> idx (within? (_.len/1 text))) - (_.return (|> text (_.slice idx (..inc idx)) _.ord/1 ..i64::64)) + (_.return (|> text (_.slice idx (..++ idx)) _.ord/1 ..i64::64)) (_.raise (_.Exception/1 (_.unicode "[Lux Error] Cannot get char from text."))))) (def: runtime::text diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/structure.lux index 1ab751074..756e3f00d 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/python/structure.lux @@ -1,6 +1,6 @@ (.module: [library - [lux #* + [lux (#- Variant Tuple) [abstract ["." monad (#+ do)]] [target @@ -31,7 +31,7 @@ (def: .public (variant generate archive [lefts right? valueS]) (Generator (Variant Synthesis)) (let [tag (if right? - (inc lefts) + (++ lefts) lefts)] (///////phase\map (//runtime.variant tag right?) (generate archive valueS)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/case.lux index cd41e5f3d..288fdc4bf 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/case.lux @@ -187,7 +187,7 @@ ..fail! (..push_cursor! $temp))))]) ([/////synthesis.side/left false (<|)] - [/////synthesis.side/right true inc]) + [/////synthesis.side/right true ++]) (^ (/////synthesis.member/left 0)) (///////phase\in (_.item (_.int +1) ..peek)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/function.lux index 34334c668..4ae6231c5 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/function.lux @@ -68,8 +68,8 @@ (def: (input_declaration register) (-> Register Expression) - (_.set! (|> register inc //case.register) - (|> $curried (_.item (|> register inc .int _.int))))) + (_.set! (|> register ++ //case.register) + (|> $curried (_.item (|> register ++ .int _.int))))) (def: .public (function expression archive [environment arity bodyS]) (Generator (Abstraction Synthesis)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/procedure/common.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/procedure/common.lux index e6134cb95..624826639 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/procedure/common.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/procedure/common.lux @@ -67,7 +67,7 @@ arity s.nat]) (with_identifiers [g!_ g!proc g!name g!translate g!inputs] (do {@ macro.monad} - [g!input+ (monad.seq @ (list.repeated arity (macro.identifier "input")))] + [g!input+ (monad.all @ (list.repeated arity (macro.identifier "input")))] (in (list (` (def: .public ((~ (code.local_identifier name)) (~ g!proc)) (-> (-> (..Vector (~ (code.nat arity)) Expression) Expression) (-> Text ..Proc)) @@ -79,7 +79,7 @@ [(~+ (|> g!input+ (list/map (function (_ g!input) (list g!input (` ((~ g!translate) (~ g!input)))))) - list.joined))] + list.together))] ((~' in) ((~ g!proc) [(~+ g!input+)]))) (~' _) @@ -125,7 +125,7 @@ (-> Text Proc) (function (_ proc_name) (function (_ translate inputsS) - (case (s.result inputsS ($_ p.seq s.nat (s.tuple (p.many s.any)) s.any)) + (case (s.result inputsS ($_ p.and s.nat (s.tuple (p.many s.any)) s.any)) (#e.Success [offset initsS+ bodyS]) (loopT.translate_loop translate offset initsS+ bodyS) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/runtime.lux index 36e86df65..21f2ded5a 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/runtime.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- Location inc i64) + [lux (#- Location ++ i64) ["." meta] [abstract ["." monad (#+ do)]] @@ -79,13 +79,13 @@ (syntax: .public (with_vars [vars (<code>.tuple (<>.some <code>.local_identifier)) body <code>.any]) (do {! meta.monad} - [ids (monad.seq ! (list.repeated (list.size vars) meta.seed))] + [ids (monad.all ! (list.repeated (list.size vars) meta.seed))] (in (list (` (let [(~+ (|> vars (list.zipped/2 ids) (list\map (function (_ [id var]) (list (code.local_identifier var) (` (_.var (~ (code.text (format "v" (%.nat id))))))))) - list.joined))] + list.together))] (~ body))))))) (syntax: (runtime: [declaration (<>.or <code>.local_identifier @@ -718,7 +718,7 @@ @frac::decode )) -(def: inc +(def: ++ (-> Expression Expression) (|>> (_.+ (_.int +1)))) @@ -749,8 +749,8 @@ ($_ _.then (_.set! idx (|> (_.apply_kw (list param (_.if (|> startF (_.= (_.int +0))) subject - (text_clip (inc startF) - (inc subjectL) + (text_clip (++ startF) + (++ subjectL) subject))) (list ["fixed" (_.bool #1)]) (_.var "regexpr")) @@ -766,7 +766,7 @@ (_.set! length (_.length text)) (_.set! to (_.+ additional minimum)) (_.if (within? length to) - (..some (text_clip (inc minimum) (inc to) text)) + (..some (text_clip (++ minimum) (++ to) text)) ..none)))) (def: (char_at idx text) @@ -777,7 +777,7 @@ (runtime: (text::char text idx) (_.if (|> idx (within? (_.length text))) ($_ _.then - (_.set! idx (inc idx)) + (_.set! idx (++ idx)) (..some (i64::of_float (char_at idx text)))) ..none)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/structure.lux index 3c74989df..748f56955 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/r/structure.lux @@ -34,7 +34,7 @@ (def: .public (variant expression archive [lefts right? valueS]) (Generator (Variant Synthesis)) (let [tag (if right? - (inc lefts) + (++ lefts) lefts)] (///////phase\map (|>> (//runtime.variant tag right?)) (expression archive valueS)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/reference.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/reference.lux index 608bffb04..26ccf116d 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/reference.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/reference.lux @@ -1,6 +1,6 @@ (.module: [library - [lux #* + [lux (#- local) ["@" target] [data [text diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux index fa95d1ba3..2af4e0dee 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux @@ -151,7 +151,7 @@ (..push! @temp)))))] [left_choice _.nil (<|)] - [right_choice (_.string "") inc] + [right_choice (_.string "") ++] ) (def: (with_looping in_closure? g!once g!continue? body!) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux index b64895b0e..192807829 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux @@ -61,7 +61,7 @@ (_.apply/* inits @self)]))) (def: input - (|>> inc //case.register)) + (|>> ++ //case.register)) (def: .public (function statement expression archive [environment arity bodyS]) (-> Phase! (Generator (Abstraction Synthesis))) @@ -73,7 +73,7 @@ .let [function_name (///reference.artifact [function_module function_artifact]) @curried (_.local "curried") arityO (|> arity .int _.int) - limitO (|> arity dec .int _.int) + limitO (|> arity -- .int _.int) @num_args (_.local "num_args") @self (_.local function_name) initialize_self! (_.set (list (//case.register 0)) @self) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux index 1bcb1d528..8a825e466 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- inc) + [lux #* ["." meta] [abstract ["." monad (#+ do)]] @@ -74,13 +74,13 @@ (syntax: .public (with_vars [vars (<code>.tuple (<>.some <code>.local_identifier)) body <code>.any]) (do {! meta.monad} - [ids (monad.seq ! (list.repeated (list.size vars) meta.seed))] + [ids (monad.all ! (list.repeated (list.size vars) meta.seed))] (in (list (` (let [(~+ (|> vars (list.zipped/2 ids) (list\map (function (_ [id var]) (list (code.local_identifier var) (` (_.local (~ (code.text (format "v" (%.nat id))))))))) - list.joined))] + list.together))] (~ body))))))) (def: module_id diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux index f51cad8bc..57861f7d4 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux @@ -31,7 +31,7 @@ (def: .public (variant generate archive [lefts right? valueS]) (Generator (Variant Synthesis)) (let [tag (if right? - (inc lefts) + (++ lefts) lefts)] (///////phase\map (//runtime.variant tag right?) (generate archive valueS)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux index 70dfee409..ae841dc5b 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/case.lux @@ -180,7 +180,7 @@ ..fail! (push_cursor! @temp))))]) ([/////synthesis.side/left false (<|)] - [/////synthesis.side/right true inc]) + [/////synthesis.side/right true ++]) (^ (/////synthesis.member/left 0)) (///////phase\in (..push_cursor! (_.vector_ref/2 ..peek (_.int +0)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/extension/common.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/extension/common.lux index c52ecd6dd..dc3c75d98 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/extension/common.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/extension/common.lux @@ -42,7 +42,7 @@ arity <code>.nat]) (with_identifiers [g!_ g!extension g!name g!phase g!inputs] (do {! macro.monad} - [g!input+ (monad.seq ! (list.repeated arity (macro.identifier "input")))] + [g!input+ (monad.all ! (list.repeated arity (macro.identifier "input")))] (in (list (` (def: .public ((~ (code.local_identifier name)) (~ g!extension)) (-> (-> (..Vector (~ (code.nat arity)) Expression) Computation) Handler) @@ -53,7 +53,7 @@ [(~+ (|> g!input+ (list\map (function (_ g!input) (list g!input (` ((~ g!phase) (~ g!input)))))) - list.joined))] + list.together))] ((~' in) ((~ g!extension) [(~+ g!input+)]))) (~' _) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux index a36feb036..58d8b55c6 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/function.lux @@ -58,7 +58,7 @@ (def: @missing (_.var "missing")) (def: input - (|>> inc //case.register)) + (|>> ++ //case.register)) (def: .public (function expression archive [environment arity bodyS]) (Generator (Abstraction Synthesis)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux index 95dfef826..452da33ef 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/runtime.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- Location inc) + [lux (#- Location) ["." meta] [abstract ["." monad (#+ do)]] @@ -61,13 +61,13 @@ (syntax: .public (with_vars [vars (<code>.tuple (<>.some <code>.local_identifier)) body <code>.any]) (do {! meta.monad} - [ids (monad.seq ! (list.repeated (list.size vars) meta.seed))] + [ids (monad.all ! (list.repeated (list.size vars) meta.seed))] (in (list (` (let [(~+ (|> vars (list.zipped/2 ids) (list\map (function (_ [id var]) (list (code.local_identifier var) (` (_.var (~ (code.text (format "v" (%.nat id))))))))) - list.joined))] + list.together))] (~ body))))))) (syntax: (runtime: [declaration (<>.or <code>.local_identifier diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux index ebc933d4c..3c21b5e17 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/scheme/structure.lux @@ -34,7 +34,7 @@ (def: .public (variant expression archive [lefts right? valueS]) (Generator (Variant Synthesis)) (let [tag (if right? - (inc lefts) + (++ lefts) lefts)] (///////phase\map (|>> [tag right?] //runtime.variant) (expression archive valueS)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux index c234f9902..9e80130aa 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux @@ -59,8 +59,8 @@ (case structure (#///analysis.Variant variant) (do phase.monad - [valueS (optimization' (get@ #///analysis.value variant))] - (in (/.variant (set@ #///analysis.value valueS variant)))) + [valueS (optimization' (value@ #///analysis.value variant))] + (in (/.variant (with@ #///analysis.value valueS variant)))) (#///analysis.Tuple tuple) (|> tuple diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux index 7f2666d8b..1a178900e 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux @@ -71,7 +71,7 @@ thenC) (#///analysis.Complex (#///analysis.Tuple tuple)) - (let [tuple::last (dec (list.size tuple))] + (let [tuple::last (-- (list.size tuple))] (list\fold (function (_ [tuple::lefts tuple::member] nextC) (.case tuple::member (#///analysis.Simple #///analysis.Unit) @@ -81,7 +81,7 @@ (let [right? (n.= tuple::last tuple::lefts) end?' (and end? right?)] (<| (///\map (|>> (#/.Seq (#/.Access (#/.Member (if right? - (#.Right (dec tuple::lefts)) + (#.Right (-- tuple::lefts)) (#.Left tuple::lefts))))))) (path' tuple::member end?') (when> [(new> (not end?') [])] [(///\map ..clean_up)]) @@ -193,10 +193,10 @@ (loop [lefts 0 patterns patterns] (with_expansions [<failure> (as_is (list)) - <continue> (as_is (recur (inc lefts) + <continue> (as_is (recur (++ lefts) tail)) <member> (as_is (if (list.empty? tail) - (#.Right (dec lefts)) + (#.Right (-- lefts)) (#.Left lefts)))] (case patterns #.End @@ -308,7 +308,7 @@ (case path (^ (/.path/seq #/.Pop path')) (let [[pops post_pops] (count_pops path')] - [(inc pops) post_pops]) + [(++ pops) post_pops]) _ [0 path])) @@ -341,8 +341,8 @@ path_storage (^ (/.path/bind register)) - (update@ #bindings (set.has register) - path_storage) + (revised@ #bindings (set.has register) + path_storage) (#/.Bit_Fork _ default otherwise) (|> (case otherwise @@ -376,12 +376,12 @@ (list\fold for_synthesis synthesis_storage members) (#/.Reference (#///reference.Variable (#///reference/variable.Local register))) - (if (set.member? (get@ #bindings synthesis_storage) register) + (if (set.member? (value@ #bindings synthesis_storage) register) synthesis_storage - (update@ #dependencies (set.has (#///reference/variable.Local register)) synthesis_storage)) + (revised@ #dependencies (set.has (#///reference/variable.Local register)) synthesis_storage)) (#/.Reference (#///reference.Variable var)) - (update@ #dependencies (set.has var) synthesis_storage) + (revised@ #dependencies (set.has var) synthesis_storage) (^ (/.function/apply [functionS argsS])) (list\fold for_synthesis synthesis_storage (#.Item functionS argsS)) @@ -390,17 +390,17 @@ (list\fold for_synthesis synthesis_storage environment) (^ (/.branch/case [inputS pathS])) - (update@ #dependencies - (set.union (get@ #dependencies (for_path pathS synthesis_storage))) - (for_synthesis inputS synthesis_storage)) + (revised@ #dependencies + (set.union (value@ #dependencies (for_path pathS synthesis_storage))) + (for_synthesis inputS synthesis_storage)) (^ (/.branch/let [inputS register exprS])) - (update@ #dependencies - (set.union (|> synthesis_storage - (update@ #bindings (set.has register)) - (for_synthesis exprS) - (get@ #dependencies))) - (for_synthesis inputS synthesis_storage)) + (revised@ #dependencies + (set.union (|> synthesis_storage + (revised@ #bindings (set.has register)) + (for_synthesis exprS) + (value@ #dependencies))) + (for_synthesis inputS synthesis_storage)) (^ (/.branch/if [testS thenS elseS])) (list\fold for_synthesis synthesis_storage (list testS thenS elseS)) @@ -409,15 +409,15 @@ (for_synthesis whole synthesis_storage) (^ (/.loop/scope [start initsS+ iterationS])) - (update@ #dependencies - (set.union (|> synthesis_storage - (update@ #bindings (set.union (|> initsS+ - list.enumeration - (list\map (|>> product.left (n.+ start))) - (set.of_list n.hash)))) - (for_synthesis iterationS) - (get@ #dependencies))) - (list\fold for_synthesis synthesis_storage initsS+)) + (revised@ #dependencies + (set.union (|> synthesis_storage + (revised@ #bindings (set.union (|> initsS+ + list.enumeration + (list\map (|>> product.left (n.+ start))) + (set.of_list n.hash)))) + (for_synthesis iterationS) + (value@ #dependencies))) + (list\fold for_synthesis synthesis_storage initsS+)) (^ (/.loop/recur replacementsS+)) (list\fold for_synthesis synthesis_storage replacementsS+) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux index 7becfbe4d..1e7ca8cc3 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux @@ -55,7 +55,7 @@ (with_expansions [<apply> (as_is (/.function/apply [funcS argsS]))] (case funcS (^ (/.function/abstraction functionS)) - (if (n.= (get@ #/.arity functionS) + (if (n.= (value@ #/.arity functionS) (list.size argsS)) (do ! [locals /.locals] @@ -94,7 +94,7 @@ (-> (-> Synthesis (Operation Synthesis)) Path (Operation Path)) (case path (#/.Bind register) - (phase\in (#/.Bind (inc register))) + (phase\in (#/.Bind (++ register))) (^template [<tag>] [(<tag> left right) @@ -160,7 +160,7 @@ (#////reference.Variable variable) (case variable (#////reference/variable.Local register) - (phase\in (/.variable/local (inc register))) + (phase\in (/.variable/local (++ register))) (#////reference/variable.Foreign register) (..find_foreign environment register)) @@ -176,7 +176,7 @@ (do phase.monad [inputS' (grow environment inputS) bodyS' (grow environment bodyS)] - (in (/.branch/let [inputS' (inc register) bodyS']))) + (in (/.branch/let [inputS' (++ register) bodyS']))) (#/.If [testS thenS elseS]) (do phase.monad @@ -202,7 +202,7 @@ (do {! phase.monad} [initsS+' (monad.map ! (grow environment) initsS+) iterationS' (grow environment iterationS)] - (in (/.loop/scope [(inc start) initsS+' iterationS']))) + (in (/.loop/scope [(++ start) initsS+' iterationS']))) (#/.Recur argumentsS+) (|> argumentsS+ @@ -258,7 +258,7 @@ (grow env') (\ ! map (function (_ body) {#/.environment environment - #/.arity (inc down_arity') + #/.arity (++ down_arity') #/.body body}))) _ @@ -270,7 +270,7 @@ (case (//loop.optimization false 1 (list) abstraction) (#.Some [startL initsL bodyL]) (/.function/abstraction {#/.environment environment - #/.arity (get@ #/.arity abstraction) + #/.arity (value@ #/.arity abstraction) #/.body (/.loop/scope [startL initsL bodyL])}) #.None diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux index d9890dbc9..a615c00ef 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux @@ -24,7 +24,7 @@ (def: .public (register_optimization offset) (-> Register (-> Register Register)) - (|>> dec (n.+ offset))) + (|>> -- (n.+ offset))) (def: (path_optimization body_optimization offset) (-> (Transform Synthesis) Register (Transform Path)) @@ -86,9 +86,9 @@ (case structure (#analysis.Variant variant) (do maybe.monad - [value' (|> variant (get@ #analysis.value) (recur false))] + [value' (|> variant (value@ #analysis.value) (recur false))] (in (|> variant - (set@ #analysis.value value') + (with@ #analysis.value value') /.variant))) (#analysis.Tuple tuple) @@ -141,10 +141,10 @@ (^ (/.loop/scope scope)) (do {! maybe.monad} [inits' (|> scope - (get@ #/.inits) + (value@ #/.inits) (monad.map ! (recur false))) - iteration' (recur return? (get@ #/.iteration scope))] - (in (/.loop/scope {#/.start (|> scope (get@ #/.start) (register_optimization offset)) + iteration' (recur return? (value@ #/.iteration scope))] + (in (/.loop/scope {#/.start (|> scope (value@ #/.start) (register_optimization offset)) #/.inits inits' #/.iteration iteration'}))) @@ -183,6 +183,6 @@ (def: .public (optimization true_loop? offset inits functionS) (-> Bit Register (List Synthesis) Abstraction (Maybe [Register (List Synthesis) Synthesis])) - (|> (get@ #/.body functionS) - (body_optimization true_loop? offset (get@ #/.environment functionS) (get@ #/.arity functionS)) + (|> (value@ #/.body functionS) + (body_optimization true_loop? offset (value@ #/.environment functionS) (value@ #/.arity functionS)) (maybe\map (|>> [offset inits])))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux index feadf7fa5..cb647c284 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux @@ -29,7 +29,7 @@ (def: (prune redundant register) (-> Register Register Register) (if (n.> redundant register) - (dec register) + (-- register) register)) (type: (Remover a) @@ -44,7 +44,7 @@ (if (n.= redundant register) (recur post) (#/.Seq (#/.Bind (if (n.> redundant register) - (dec register) + (-- register) register)) (recur post))) @@ -60,7 +60,7 @@ (recur post) (#/.Seq (#/.Access (#/.Member member)) (#/.Seq (#/.Bind (if (n.> redundant register) - (dec register) + (-- register) register)) (recur post)))) @@ -188,7 +188,7 @@ (def: (default arity) (-> Arity Redundancy) - (product.right (..extended 0 (inc arity) ..initial))) + (product.right (..extended 0 (++ arity) ..initial))) (type: (Optimization a) (-> [Redundancy a] (Try [Redundancy a]))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/program.lux b/stdlib/source/library/lux/tool/compiler/language/lux/program.lux index 365f9e804..f181fd077 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/program.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/program.lux @@ -42,7 +42,7 @@ (do ! [id (archive.id module archive) [descriptor document] (archive.find module archive)] - (in [[module id] (get@ #descriptor.registry descriptor)])))))] + (in [[module id] (value@ #descriptor.registry descriptor)])))))] (case (list.one (function (_ [[module module_id] registry]) (do maybe.monad [program_id (artifact.remember ..name registry)] diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/syntax.lux b/stdlib/source/library/lux/tool/compiler/language/lux/syntax.lux index 15539ae10..d4b612bf2 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/syntax.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/syntax.lux @@ -70,13 +70,13 @@ (type: Char Nat) -(template [<name> <extension> <diff>] +(template [<extension> <diff> <name>] [(template: (<name> value) [(<extension> <diff> value)])] - [!inc "lux i64 +" 1] - [!inc/2 "lux i64 +" 2] - [!dec "lux i64 -" 1] + ["lux i64 +" 1 !++] + ["lux i64 +" 2 !++/2] + ["lux i64 -" 1 !--] ) (template: (!clip from to text) @@ -198,14 +198,14 @@ (:expected <<otherwise>>))]) (template: (!horizontal where offset source_code) - [[(update@ #.column inc where) - (!inc offset) + [[(revised@ #.column ++ where) + (!++ offset) source_code]]) (inline: (!new_line where) (-> Location Location) (let [[where::file where::line where::column] where] - [where::file (!inc where::line) 0])) + [where::file (!++ where::line) 0])) (inline: (!forward length where) (-> Nat Location Location) @@ -214,7 +214,7 @@ (template: (!vertical where offset source_code) [[(!new_line where) - (!inc offset) + (!++ offset) source_code]]) (template [<name> <close> <tag>] @@ -272,8 +272,8 @@ (<| (let [g!content (!clip offset g!end source_code)]) (!guarantee_no_new_lines where offset source_code g!content) (#.Right [[(let [size (!n/- offset g!end)] - (update@ #.column (|>> (!n/+ size) (!n/+ 2)) where)) - (!inc g!end) + (revised@ #.column (|>> (!n/+ size) (!n/+ 2)) where)) + (!++ g!end) source_code] [where (#.Text g!content)]])) @@ -365,11 +365,11 @@ exponent (static ..no_exponent)] (<| (!with_char+ source_code//size source_code end char/0 <frac_output>) (!if_digit?+ char/0 - (recur (!inc end) exponent) + (recur (!++ end) exponent) [["e" "E"] (if (same? (static ..no_exponent) exponent) - (<| (!with_char+ source_code//size source_code (!inc end) char/1 <failure>) + (<| (!with_char+ source_code//size source_code (!++ end) char/1 <failure>) (`` ("lux syntax char case!" char/1 [[<signs>] (<| (!with_char+ source_code//size source_code (!n/+ 2 end) char/2 <failure>) @@ -389,10 +389,10 @@ (loop [end offset] (<| (!with_char+ source_code//size source_code end char <int_output>) (!if_digit?+ char - (recur (!inc end)) + (recur (!++ end)) [[<frac_separator>] - (frac_parser source_code//size start where (!inc end) source_code)] + (frac_parser source_code//size start where (!++ end) source_code)] <int_output>)))) ) @@ -404,7 +404,7 @@ (loop [g!end offset] (<| (!with_char+ source_code//size source_code g!end g!char (!number_output source_code start g!end <codec> <tag>)) (!if_digit?+ g!char - (recur (!inc g!end)) + (recur (!++ g!end)) [] (!number_output source_code start g!end <codec> <tag>)))))] @@ -413,13 +413,13 @@ ) (template: (!signed_parser source_code//size offset where source_code @aliases @end) - [(<| (let [g!offset/1 (!inc offset)]) + [(<| (let [g!offset/1 (!++ offset)]) (!with_char+ source_code//size source_code g!offset/1 g!char/1 @end) (!if_digit? g!char/1 - (signed_parser source_code//size offset where (!inc/2 offset) source_code) - (!full_name_parser offset [where (!inc offset) source_code] where @aliases #.Identifier)))]) + (signed_parser source_code//size offset where (!++/2 offset) source_code) + (!full_name_parser offset [where (!++ offset) source_code] where @aliases #.Identifier)))]) -(with_expansions [<output> (#.Right [[(update@ #.column (|>> (!n/+ (!n/- start end))) where) +(with_expansions [<output> (#.Right [[(revised@ #.column (|>> (!n/+ (!n/- start end))) where) end source_code] (!clip start end source_code)])] @@ -430,12 +430,12 @@ (loop [end offset] (<| (!with_char+ source_code//size source_code end char <output>) (!if_name_char?|tail char - (recur (!inc end)) + (recur (!++ end)) <output>)))))) (template: (!half_name_parser @offset @char @module) [(!if_name_char?|head @char - (!letE [source' name] (..name_part_parser @offset where (!inc @offset) source_code) + (!letE [source' name] (..name_part_parser @offset where (!++ @offset) source_code) (#.Right [source' [@module name]])) (!failure ..!half_name_parser where @offset source_code))]) @@ -444,7 +444,7 @@ (<| (!with_char+ source_code//size source_code offset/0 char/0 (!end_of_file where offset/0 source_code current_module)) (if (!n/= (char (~~ (static ..name_separator))) char/0) - (<| (let [offset/1 (!inc offset/0)]) + (<| (let [offset/1 (!++ offset/0)]) (!with_char+ source_code//size source_code offset/1 char/1 (!end_of_file where offset/1 source_code current_module)) (!half_name_parser offset/1 char/1 current_module)) @@ -462,7 +462,7 @@ (let [[where' offset' source_code'] source']) (!with_char source_code' offset' char/separator <simple>) (if (!n/= (char (~~ (static ..name_separator))) char/separator) - (<| (let [offset'' (!inc offset')]) + (<| (let [offset'' (!++ offset')]) (!letE [source'' complex] (..name_part_parser offset'' (!forward 1 where') offset'' source_code')) (if ("lux text =" "" complex) (let [[where offset source_code] source] @@ -482,9 +482,9 @@ ... [expression ...] ... [form "(" [#* expression] ")"]) -(with_expansions [<consume_1> (as_is where (!inc offset/0) source_code) - <move_1> (as_is [(!forward 1 where) (!inc offset/0) source_code]) - <move_2> (as_is [(!forward 1 where) (!inc/2 offset/0) source_code]) +(with_expansions [<consume_1> (as_is where (!++ offset/0) source_code) + <move_1> (as_is [(!forward 1 where) (!++ offset/0) source_code]) + <move_2> (as_is [(!forward 1 where) (!++/2 offset/0) source_code]) <recur> (as_is (parse current_module aliases source_code//size))] (template: (!close closer) @@ -492,8 +492,8 @@ (def: (bit_syntax value [where offset/0 source_code]) (-> Bit (Parser Code)) - (#.Right [[(update@ #.column (|>> !inc/2) where) - (!inc/2 offset/0) + (#.Right [[(revised@ #.column (|>> !++/2) where) + (!++/2 offset/0) source_code] [where (#.Bit value)]])) @@ -530,11 +530,11 @@ ... Text [(~~ (static ..text_delimiter))] - (text_parser where (!inc offset/0) source_code) + (text_parser where (!++ offset/0) source_code) ... Special code [(~~ (static ..sigil))] - (<| (let [offset/1 (!inc offset/0)]) + (<| (let [offset/1 (!++ offset/0)]) (!with_char+ source_code//size source_code offset/1 char/1 (!end_of_file where offset/1 source_code current_module)) ("lux syntax char case!" char/1 @@ -559,15 +559,15 @@ ... (~~ (static ..frac_separator)) ] ... It's either a Rev, an identifier, or a comment. - (with_expansions [<rev_parser> (rev_parser source_code//size offset/0 where (!inc offset/1) source_code) + (with_expansions [<rev_parser> (rev_parser source_code//size offset/0 where (!++ offset/1) source_code) <short_name_parser> (!short_name_parser source_code//size current_module [where offset/1 source_code] where #.Identifier) - <comment_parser> (case ("lux text index" (!inc offset/1) (static text.new_line) source_code) + <comment_parser> (case ("lux text index" (!++ offset/1) (static text.new_line) source_code) (#.Some end) (recur (!vertical where end source_code)) _ (!end_of_file where offset/1 source_code current_module))] - (<| (let [offset/1 (!inc offset/0)]) + (<| (let [offset/1 (!++ offset/0)]) (!with_char+ source_code//size source_code offset/1 char/1 (!end_of_file where offset/1 source_code current_module)) (!if_digit? char/1 @@ -577,7 +577,7 @@ ("lux syntax char case!" char/1 [[(~~ (static ..name_separator))] ... It's either an identifier, or a comment. - (<| (let [offset/2 (!inc offset/1)]) + (<| (let [offset/2 (!++ offset/1)]) (!with_char+ source_code//size source_code offset/2 char/2 (!end_of_file where offset/2 source_code current_module)) ("lux syntax char case!" char/2 @@ -597,7 +597,7 @@ ... else (!if_digit? char/0 ... Natural number - (nat_parser source_code//size offset/0 where (!inc offset/0) source_code) + (nat_parser source_code//size offset/0 where (!++ offset/0) source_code) ... Identifier (!full_name_parser offset/0 [<consume_1>] where aliases #.Identifier)) ))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux index 58dc336dd..7f7d205c3 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux @@ -190,11 +190,11 @@ (template [<with> <query> <tag> <type>] [(def: .public (<with> value) (-> <type> (All [a] (-> (Operation a) (Operation a)))) - (extension.temporary (set@ <tag> value))) + (extension.temporary (with@ <tag> value))) (def: .public <query> (Operation <type>) - (extension.read (get@ <tag>)))] + (extension.read (value@ <tag>)))] [with_locals locals #locals Nat] [with_currying? currying? #currying? Bit] @@ -204,7 +204,7 @@ (All [a] (-> (Operation a) (Operation a))) (<<| (do phase.monad [locals ..locals]) - (..with_locals (inc locals)))) + (..with_locals (++ locals)))) (template [<name> <tag>] [(template: .public (<name> content) @@ -389,12 +389,12 @@ (#Loop loop) (case loop (#Scope scope) - (|> (format (%.nat (get@ #start scope)) - " " (|> (get@ #inits scope) + (|> (format (%.nat (value@ #start scope)) + " " (|> (value@ #inits scope) (list\map %synthesis) (text.interposed " ") (text.enclosed ["[" "]"])) - " " (%synthesis (get@ #iteration scope))) + " " (%synthesis (value@ #iteration scope))) (text.enclosed ["(#loop " ")"])) (#Recur args) diff --git a/stdlib/source/library/lux/tool/compiler/meta/archive.lux b/stdlib/source/library/lux/tool/compiler/meta/archive.lux index 06a2d5ca8..d810d7aca 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/archive.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/archive.lux @@ -82,7 +82,7 @@ (def: next (-> Archive ID) - (|>> :representation (get@ #next))) + (|>> :representation (value@ #next))) (def: .public empty Archive @@ -111,8 +111,8 @@ (#try.Success [next (|> archive :representation - (update@ #..resolver (dictionary.has module [next #.None])) - (update@ #..next inc) + (revised@ #..resolver (dictionary.has module [next #.None])) + (revised@ #..next ++) :abstraction)])))) (def: .public (has module [descriptor document output] archive) @@ -122,7 +122,7 @@ (#.Some [id #.None]) (#try.Success (|> archive :representation - (update@ #..resolver (dictionary.has module [id (#.Some [descriptor document output])])) + (revised@ #..resolver (dictionary.has module [id (#.Some [descriptor document output])])) :abstraction)) (#.Some [id (#.Some [existing_descriptor existing_document existing_output])]) @@ -160,7 +160,7 @@ (def: .public archived (-> Archive (List Module)) (|>> :representation - (get@ #resolver) + (value@ #resolver) dictionary.entries (list.all (function (_ [module [id descriptor+document]]) (case descriptor+document @@ -180,13 +180,13 @@ (def: .public reserved (-> Archive (List Module)) (|>> :representation - (get@ #resolver) + (value@ #resolver) dictionary.keys)) (def: .public reservations (-> Archive (List [Module ID])) (|>> :representation - (get@ #resolver) + (value@ #resolver) dictionary.entries (list\map (function (_ [module [id _]]) [module id])))) @@ -196,17 +196,17 @@ (let [[+next +resolver] (:representation additions)] (|> archive :representation - (update@ #next (n.max +next)) - (update@ #resolver (function (_ resolver) - (list\fold (function (_ [module [id entry]] resolver) - (case entry - (#.Some _) - (dictionary.has module [id entry] resolver) - - #.None - resolver)) - resolver - (dictionary.entries +resolver)))) + (revised@ #next (n.max +next)) + (revised@ #resolver (function (_ resolver) + (list\fold (function (_ [module [id entry]] resolver) + (case entry + (#.Some _) + (dictionary.has module [id entry] resolver) + + #.None + resolver)) + resolver + (dictionary.entries +resolver)))) :abstraction))) (type: Reservation @@ -281,6 +281,6 @@ {#next next #resolver (list\fold (function (_ [module id] archive) (dictionary.has module [id #.None] archive)) - (get@ #resolver (:representation ..empty)) + (value@ #resolver (:representation ..empty)) reservations)})))) ) diff --git a/stdlib/source/library/lux/tool/compiler/meta/archive/artifact.lux b/stdlib/source/library/lux/tool/compiler/meta/archive/artifact.lux index de1858b97..e4cc633de 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/archive/artifact.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/archive/artifact.lux @@ -50,7 +50,7 @@ (def: .public artifacts (-> Registry (Row Artifact)) - (|>> :representation (get@ #artifacts))) + (|>> :representation (value@ #artifacts))) (def: next (-> Registry ID) @@ -62,8 +62,8 @@ [id (|> registry :representation - (update@ #artifacts (row.add {#id id - #category #Anonymous})) + (revised@ #artifacts (row.suffix {#id id + #category #Anonymous})) :abstraction)])) (template [<tag> <create> <fetch>] @@ -73,18 +73,18 @@ [id (|> registry :representation - (update@ #artifacts (row.add {#id id - #category (<tag> name)})) - (update@ #resolver (dictionary.has name id)) + (revised@ #artifacts (row.suffix {#id id + #category (<tag> name)})) + (revised@ #resolver (dictionary.has name id)) :abstraction)])) (def: .public (<fetch> registry) (-> Registry (List Text)) (|> registry :representation - (get@ #artifacts) + (value@ #artifacts) row.list - (list.all (|>> (get@ #category) + (list.all (|>> (value@ #category) (case> (<tag> name) (#.Some name) _ #.None)))))] @@ -99,7 +99,7 @@ (def: .public (remember name registry) (-> Text Registry (Maybe ID)) (|> (:representation registry) - (get@ #resolver) + (value@ #resolver) (dictionary.value name))) (def: .public writer @@ -119,8 +119,8 @@ artifacts (: (Writer (Row Category)) (binary.row/64 category))] (|>> :representation - (get@ #artifacts) - (row\map (get@ #category)) + (value@ #artifacts) + (row\map (value@ #category)) artifacts))) (exception: .public (invalid_category {tag Nat}) diff --git a/stdlib/source/library/lux/tool/compiler/meta/archive/document.lux b/stdlib/source/library/lux/tool/compiler/meta/archive/document.lux index 30777c282..a14d708d5 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/archive/document.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/archive/document.lux @@ -59,7 +59,7 @@ (def: .public signature (-> (Document Any) Signature) - (|>> :representation (get@ #signature))) + (|>> :representation (value@ #signature))) (def: .public (writer content) (All [d] (-> (Writer d) (Writer (Document d)))) diff --git a/stdlib/source/library/lux/tool/compiler/meta/archive/signature.lux b/stdlib/source/library/lux/tool/compiler/meta/archive/signature.lux index bc413b413..8b4dfedb8 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/archive/signature.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/archive/signature.lux @@ -29,7 +29,7 @@ (def: .public (description signature) (-> Signature Text) - (format (%.name (get@ #name signature)) " " (%.nat (get@ #version signature)))) + (format (%.name (value@ #name signature)) " " (%.nat (value@ #version signature)))) (def: .public writer (Writer Signature) diff --git a/stdlib/source/library/lux/tool/compiler/meta/cache/dependency.lux b/stdlib/source/library/lux/tool/compiler/meta/cache/dependency.lux index 2df8c36ec..6ee936f42 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/cache/dependency.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/cache/dependency.lux @@ -57,7 +57,7 @@ (do {! state.monad} [.let [parents (case (archive.find module archive) (#try.Success [descriptor document]) - (get@ #descriptor.references descriptor) + (value@ #descriptor.references descriptor) (#try.Failure error) ..fresh)] diff --git a/stdlib/source/library/lux/tool/compiler/meta/io/archive.lux b/stdlib/source/library/lux/tool/compiler/meta/io/archive.lux index c5483ac0c..b4fa30d12 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/io/archive.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/io/archive.lux @@ -61,9 +61,9 @@ (def: (archive fs static) (All [!] (-> (file.System !) Static file.Path)) - (format (get@ #static.target static) + (format (value@ #static.target static) (\ fs separator) - (get@ #static.host static))) + (value@ #static.host static))) (def: (unversioned_lux_archive fs static) (All [!] (-> (file.System !) Static file.Path)) @@ -88,7 +88,7 @@ (format (..module fs static module_id) (\ fs separator) (%.nat artifact_id) - (get@ #static.artifact_extension static))) + (value@ #static.artifact_extension static))) (def: (ensure_directory fs path) (-> (file.System Async) file.Path (Async (Try Any))) @@ -125,7 +125,7 @@ (def: .public (enable fs static) (-> (file.System Async) Static (Async (Try Any))) (do (try.with async.monad) - [_ (..ensure_directory fs (get@ #static.target static))] + [_ (..ensure_directory fs (value@ #static.target static))] (..ensure_directory fs (..archive fs static)))) (def: (general_descriptor fs static) @@ -174,7 +174,7 @@ content (document.read $.key document)] (in [module content]))) (archive.archived archive)))] - (in (set@ #.modules modules (fresh_analysis_state host))))) + (in (with@ #.modules modules (fresh_analysis_state host))))) (def: (cached_artifacts fs static module_id) (-> (file.System Async) Static archive.ID (Async (Try (Dictionary Text Binary)))) @@ -231,7 +231,7 @@ (case artifact_category #artifact.Anonymous (do ! - [.let [output (row.add [artifact_id #.None data] output)] + [.let [output (row.suffix [artifact_id #.None data] output)] _ (\ host re_learn context #.None directive)] (in [definitions [analysers @@ -241,7 +241,7 @@ output])) (#artifact.Definition name) - (let [output (row.add [artifact_id #.None data] output)] + (let [output (row.suffix [artifact_id #.None data] output)] (if (text\= $/program.name name) (in [definitions [analysers @@ -260,7 +260,7 @@ (#artifact.Analyser extension) (do ! - [.let [output (row.add [artifact_id #.None data] output)] + [.let [output (row.suffix [artifact_id #.None data] output)] value (\ host re_load context #.None directive)] (in [definitions [(dictionary.has extension (:as analysis.Handler value) analysers) @@ -271,7 +271,7 @@ (#artifact.Synthesizer extension) (do ! - [.let [output (row.add [artifact_id #.None data] output)] + [.let [output (row.suffix [artifact_id #.None data] output)] value (\ host re_load context #.None directive)] (in [definitions [analysers @@ -282,7 +282,7 @@ (#artifact.Generator extension) (do ! - [.let [output (row.add [artifact_id #.None data] output)] + [.let [output (row.suffix [artifact_id #.None data] output)] value (\ host re_load context #.None directive)] (in [definitions [analysers @@ -293,7 +293,7 @@ (#artifact.Directive extension) (do ! - [.let [output (row.add [artifact_id #.None data] output)] + [.let [output (row.suffix [artifact_id #.None data] output)] value (\ host re_load context #.None directive)] (in [definitions [analysers @@ -304,7 +304,7 @@ (#artifact.Custom name) (do ! - [.let [output (row.add [artifact_id (#.Some name) data] output)] + [.let [output (row.suffix [artifact_id (#.Some name) data] output)] _ (\ host re_learn context (#.Some name) directive)] (in [definitions [analysers @@ -333,8 +333,8 @@ (\ ! map (|>> [exported? type annotations] #.Definition [def_name]))))) - (get@ #.definitions content))] - (in [(document.write $.key (set@ #.definitions definitions content)) + (value@ #.definitions content))] + (in [(document.write $.key (with@ #.definitions definitions content)) bundles]))) (def: (load_definitions fs static module_id host_environment descriptor document) @@ -345,8 +345,8 @@ Bundles])))) (do (try.with async.monad) [actual (cached_artifacts fs static module_id) - .let [expected (|> descriptor (get@ #descriptor.registry) artifact.artifacts)] - [document bundles output] (async\in (loaded_document (get@ #static.artifact_extension static) host_environment module_id expected actual document))] + .let [expected (|> descriptor (value@ #descriptor.registry) artifact.artifacts)] + [document bundles output] (async\in (loaded_document (value@ #static.artifact_extension static) host_environment module_id expected actual document))] (in [[descriptor document output] bundles]))) (def: (purge! fs static [module_name module_id]) @@ -361,12 +361,12 @@ (def: (valid_cache? expected actual) (-> Descriptor Input Bit) - (and (text\= (get@ #descriptor.name expected) - (get@ #////.module actual)) - (text\= (get@ #descriptor.file expected) - (get@ #////.file actual)) - (n.= (get@ #descriptor.hash expected) - (get@ #////.hash actual)))) + (and (text\= (value@ #descriptor.name expected) + (value@ #////.module actual)) + (text\= (value@ #descriptor.file expected) + (value@ #////.file actual)) + (n.= (value@ #descriptor.hash expected) + (value@ #////.hash actual)))) (type: Purge (Dictionary Module archive.ID)) @@ -390,7 +390,7 @@ (if (purged? module_name) purge (if (|> descriptor - (get@ #descriptor.references) + (value@ #descriptor.references) set.list (list.any? purged?)) (dictionary.has module_name module_id purge) @@ -417,7 +417,7 @@ (in [true [module_name [module_id [descriptor document]]]]) (do ! - [input (//context.read fs ..pseudo_module import contexts (get@ #static.host_module_extension static) module_name)] + [input (//context.read fs ..pseudo_module import contexts (value@ #static.host_module_extension static) module_name)] (in [(..valid_cache? descriptor input) [module_name [module_id [descriptor document]]]]))))))) load_order (|> pre_loaded_caches @@ -447,7 +447,7 @@ (archive.has module descriptor,document,output archive)) archive loaded_caches) - analysis_state (..analysis_state (get@ #static.host static) archive)] + analysis_state (..analysis_state (value@ #static.host static) archive)] (in [archive analysis_state (list\fold (function (_ [_ [+analysers +synthesizers +generators +directives]] @@ -473,5 +473,5 @@ (#try.Failure error) (in (#try.Success [archive.empty - (fresh_analysis_state (get@ #static.host static)) + (fresh_analysis_state (value@ #static.host static)) ..empty_bundles]))))) diff --git a/stdlib/source/library/lux/tool/compiler/meta/io/context.lux b/stdlib/source/library/lux/tool/compiler/meta/io/context.lux index 0c7969507..979edaa76 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/io/context.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/io/context.lux @@ -6,6 +6,7 @@ [predicate (#+ Predicate)] ["." monad (#+ Monad do)]] [control + ["." maybe] ["." try (#+ Try)] ["." exception (#+ exception:)] [concurrency @@ -17,7 +18,8 @@ [encoding ["." utf8]]] [collection - ["." dictionary (#+ Dictionary)]]] + ["." dictionary (#+ Dictionary)] + ["." list]]] [world ["." file]]]] [program @@ -138,8 +140,8 @@ (type: .public Enumeration (Dictionary file.Path Binary)) -(def: (context_listing fs directory enumeration) - (-> (file.System Async) Context Enumeration (Async (Try Enumeration))) +(def: (context_listing fs context directory enumeration) + (-> (file.System Async) Context file.Path Enumeration (Async (Try Enumeration))) (do {! (try.with async.monad)} [enumeration (|> directory (\ fs directory_files) @@ -147,23 +149,40 @@ (if (text.ends_with? ..lux_extension file) (do ! [source_code (\ fs read file)] - (async\in (dictionary.has' (file.name fs file) source_code enumeration))) + (async\in (dictionary.has' (text.replaced context "" file) source_code enumeration))) (in enumeration))) enumeration)) (\ ! join))] (|> directory (\ fs sub_directories) - (\ ! map (monad.fold ! (context_listing fs) enumeration)) + (\ ! map (monad.fold ! (context_listing fs context) enumeration)) (\ ! join)))) (def: Action (type (All [a] (Async (Try a))))) +(def: (canonical fs context) + (-> (file.System Async) Context (Action Context)) + (do (try.with async.monad) + [subs (\ fs sub_directories context)] + (in (|> subs + list.head + (maybe.else context) + (file.parent fs) + (maybe.else context))))) + (def: .public (listing fs contexts) (-> (file.System Async) (List Context) (Action Enumeration)) - (monad.fold (: (Monad Action) - (try.with async.monad)) - (..context_listing fs) - (: Enumeration - (dictionary.empty text.hash)) - contexts)) + (let [! (: (Monad Action) + (try.with async.monad))] + (monad.fold ! + (function (_ context enumeration) + (do ! + [context (..canonical fs context)] + (..context_listing fs + (format context (\ fs separator)) + context + enumeration))) + (: Enumeration + (dictionary.empty text.hash)) + contexts))) diff --git a/stdlib/source/library/lux/tool/compiler/meta/packager.lux b/stdlib/source/library/lux/tool/compiler/meta/packager.lux index 21c15d551..744d0ecb9 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/packager.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/packager.lux @@ -35,8 +35,8 @@ (-> dependency.Order Order) (list\map (function (_ [module [module_id [descriptor document]]]) (|> descriptor - (get@ #descriptor.registry) + (value@ #descriptor.registry) artifact.artifacts row.list - (list\map (|>> (get@ #artifact.id))) + (list\map (|>> (value@ #artifact.id))) [module_id])))) diff --git a/stdlib/source/library/lux/tool/compiler/meta/packager/jvm.lux b/stdlib/source/library/lux/tool/compiler/meta/packager/jvm.lux index 06ef9b25b..d9707b0c0 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/packager/jvm.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/packager/jvm.lux @@ -143,7 +143,7 @@ (let [class_path (|> custom (maybe\map (|>> name.internal name.read)) (maybe.else (runtime.class_name [module artifact])) - (text.suffix (get@ #static.artifact_extension static)))] + (text.suffix (value@ #static.artifact_extension static)))] (do try.monad [_ (java/util/jar/JarOutputStream::putNextEntry (java/util/jar/JarEntry::new class_path) sink)] (in (do_to sink diff --git a/stdlib/source/library/lux/tool/compiler/meta/packager/scheme.lux b/stdlib/source/library/lux/tool/compiler/meta/packager/scheme.lux index 90d28197a..a229c78a1 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/packager/scheme.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/packager/scheme.lux @@ -104,7 +104,7 @@ (..bundle_module output)) entry_content (: (Try tar.Content) (|> descriptor - (get@ #descriptor.references) + (value@ #descriptor.references) set.list (list.all (function (_ module) (dictionary.value module mapping))) (list\map (|>> ..module_file _.string _.load_relative/1)) diff --git a/stdlib/source/library/lux/tool/interpreter.lux b/stdlib/source/library/lux/tool/interpreter.lux index 6e28d5c1a..ee02eacc9 100644 --- a/stdlib/source/library/lux/tool/interpreter.lux +++ b/stdlib/source/library/lux/tool/interpreter.lux @@ -75,14 +75,14 @@ (do Monad<!> [state (platform.initialize platform generation_bundle) state (platform.compile platform - (set@ #cli.module syntax.prelude configuration) - (set@ [#extension.state - #directive.analysis #directive.state - #extension.state - #.info #.mode] - #.Interpreter - state)) - [state _] (\ (get@ #platform.file_system platform) + (with@ #cli.module syntax.prelude configuration) + (with@ [#extension.state + #directive.analysis #directive.state + #extension.state + #.info #.mode] + #.Interpreter + state)) + [state _] (\ (value@ #platform.file_system platform) lift (phase.result' state enter_module)) _ (\ Console<!> write ..welcome_message)] (in state))) @@ -102,9 +102,9 @@ (-> Code <Interpretation>)) (do {! phase.monad} [state (extension.lifted phase.get_state) - .let [analyse (get@ [#directive.analysis #directive.phase] state) - synthesize (get@ [#directive.synthesis #directive.phase] state) - generate (get@ [#directive.generation #directive.phase] state)] + .let [analyse (value@ [#directive.analysis #directive.phase] state) + synthesize (value@ [#directive.synthesis #directive.phase] state) + generate (value@ [#directive.generation #directive.phase] state)] [_ codeT codeA] (directive.lifted_analysis (analysis.with_scope (type.with_fresh_env @@ -154,10 +154,10 @@ (do phase.monad [[codeT codeV] (interpret configuration code) state phase.get_state] - (in (/type.represent (get@ [#extension.state - #directive.analysis #directive.state - #extension.state] - state) + (in (/type.represent (value@ [#extension.state + #directive.analysis #directive.state + #extension.state] + state) codeT codeV)))) @@ -171,24 +171,24 @@ (All [anchor expression directive] (-> <Context> (Try [<Context> Text]))) (do try.monad - [.let [[_where _offset _code] (get@ #source context)] - [source' input] (syntax.parse ..module syntax.no_aliases (text.size _code) (get@ #source context)) + [.let [[_where _offset _code] (value@ #source context)] + [source' input] (syntax.parse ..module syntax.no_aliases (text.size _code) (value@ #source context)) [state' representation] (let [... TODO: Simplify ASAP state (:sharing [anchor expression directive] {<Context> context} {(State+ anchor expression directive) - (get@ #state context)})] + (value@ #state context)})] (<| (phase.result' state) ... TODO: Simplify ASAP (:sharing [anchor expression directive] {<Context> context} {(Operation anchor expression directive Text) - (execute (get@ #configuration context) input)})))] + (execute (value@ #configuration context) input)})))] (in [(|> context - (set@ #state state') - (set@ #source source')) + (with@ #state state') + (with@ #source source')) representation])))) (def: .public (run! Monad<!> Console<!> platform configuration generation_bundle) @@ -212,7 +212,7 @@ (if (and (not multi_line?) (text\= ..exit_command line)) (\ Console<!> write ..farewell_message) - (case (read_eval_print (update@ #source (add_line line) context)) + (case (read_eval_print (revised@ #source (add_line line) context)) (#try.Success [context' representation]) (do ! [_ (\ Console<!> write representation)] @@ -222,5 +222,5 @@ (if (ex.match? syntax.end_of_file error) (recur context #1) (exec (log! (ex.error ..error error)) - (recur (set@ #source ..fresh_source context) #0)))))) + (recur (with@ #source ..fresh_source context) #0)))))) ))) diff --git a/stdlib/source/library/lux/type.lux b/stdlib/source/library/lux/type.lux index c6be00945..2a99dded3 100644 --- a/stdlib/source/library/lux/type.lux +++ b/stdlib/source/library/lux/type.lux @@ -36,7 +36,7 @@ type type] (case type (<tag> env sub_type) - (recur (inc num_args) sub_type) + (recur (++ num_args) sub_type) _ [num_args type])))] @@ -345,7 +345,7 @@ (-> Nat Type Type) (case size 0 body - _ (|> body (<name> (dec size)) (<tag> (list)))))] + _ (|> body (<name> (-- size)) (<tag> (list)))))] [univ_q #.UnivQ] [ex_q #.ExQ] @@ -375,7 +375,7 @@ (case depth 0 element_type _ (|> element_type - (array (dec depth)) + (array (-- depth)) (list) (#.Primitive array.type_name)))) @@ -386,7 +386,7 @@ (^multi (^ (#.Primitive name (list element_type))) (text\= array.type_name name)) (let [[depth element_type] (flat_array element_type)] - [(inc depth) element_type]) + [(++ depth) element_type]) _ [0 type])) @@ -487,11 +487,11 @@ (bar expression))))} (macro.with_identifiers [g!_] (let [shareC (` (: (All [(~+ (list\map code.local_identifier type_vars))] - (-> (~ (get@ #type exemplar)) - (~ (get@ #type computation)))) + (-> (~ (value@ #type exemplar)) + (~ (value@ #type computation)))) (.function ((~ g!_) (~ g!_)) - (~ (get@ #expression computation)))))] - (in (list (` ((~ shareC) (~ (get@ #expression exemplar))))))))) + (~ (value@ #expression computation)))))] + (in (list (` ((~ shareC) (~ (value@ #expression exemplar))))))))) (syntax: .public (:by_example [type_vars ..type_parameters exemplar ..typed @@ -509,8 +509,8 @@ (in (list (` (:of ((~! :sharing) [(~+ (list\map code.local_identifier type_vars))] - (~ (get@ #type exemplar)) - (~ (get@ #expression exemplar)) + (~ (value@ #type exemplar)) + (~ (value@ #expression exemplar)) (~ extraction) (:expected []))))))) diff --git a/stdlib/source/library/lux/type/abstract.lux b/stdlib/source/library/lux/type/abstract.lux index 25c864755..9b657cb19 100644 --- a/stdlib/source/library/lux/type/abstract.lux +++ b/stdlib/source/library/lux/type/abstract.lux @@ -69,7 +69,7 @@ (def: (peek_frames reference definition_reference source) (-> Text Text (List [Text Module]) (Stack Frame)) (!peek source reference - (peek_frames_definition definition_reference (get@ #.definitions head)))) + (peek_frames_definition definition_reference (value@ #.definitions head)))) (exception: .public no_active_frames) @@ -77,7 +77,7 @@ (-> (Maybe Text) (Meta Frame)) (function (_ compiler) (let [[reference definition_reference] (name_of ..frames) - current_frames (peek_frames reference definition_reference (get@ #.modules compiler))] + current_frames (peek_frames reference definition_reference (value@ #.modules compiler))] (case (case frame (#.Some frame) (list.example (function (_ [actual _]) @@ -131,14 +131,14 @@ (def: (push_frame [module_reference definition_reference] frame source) (-> Name Frame (List [Text Module]) (List [Text Module])) (!push source module_reference - (update@ #.definitions (push_frame_definition definition_reference frame) head))) + (revised@ #.definitions (push_frame_definition definition_reference frame) head))) (def: (push! frame) (-> Frame (Meta Any)) (function (_ compiler) - (#.Right [(update@ #.modules - (..push_frame (name_of ..frames) frame) - compiler) + (#.Right [(revised@ #.modules + (..push_frame (name_of ..frames) frame) + compiler) []]))) (def: (pop_frame_definition reference source) @@ -163,13 +163,13 @@ (def: (pop_frame [module_reference definition_reference] source) (-> Name (List [Text Module]) (List [Text Module])) (!push source module_reference - (|> head (update@ #.definitions (pop_frame_definition definition_reference))))) + (|> head (revised@ #.definitions (pop_frame_definition definition_reference))))) (syntax: (pop! []) (function (_ compiler) - (#.Right [(update@ #.modules - (..pop_frame (name_of ..frames)) - compiler) + (#.Right [(revised@ #.modules + (..pop_frame (name_of ..frames)) + compiler) (list)]))) (def: cast diff --git a/stdlib/source/library/lux/type/check.lux b/stdlib/source/library/lux/type/check.lux index b4aedaef1..aa8e213af 100644 --- a/stdlib/source/library/lux/type/check.lux +++ b/stdlib/source/library/lux/type/check.lux @@ -188,15 +188,15 @@ {#.doc "A brand-new existential type."} (Check [Nat Type]) (function (_ context) - (let [id (get@ #.ex_counter context)] - (#try.Success [(update@ #.ex_counter inc context) + (let [id (value@ #.ex_counter context)] + (#try.Success [(revised@ #.ex_counter ++ context) [id (#.Ex id)]])))) (template [<name> <outputT> <fail> <succeed>] [(def: .public (<name> id) (-> Var (Check <outputT>)) (function (_ context) - (case (|> context (get@ #.var_bindings) (var::get id)) + (case (|> context (value@ #.var_bindings) (var::get id)) (^or (#.Some (#.Some (#.Var _))) (#.Some #.None)) (#try.Success [context <fail>]) @@ -208,13 +208,13 @@ (exception.except ..unknown_type_var id))))] [bound? Bit false true] - [read (Maybe Type) #.None (#.Some bound)] + [read' (Maybe Type) #.None (#.Some bound)] ) -(def: .public (read! id) +(def: .public (read id) (-> Var (Check Type)) (do ..monad - [?type (read id)] + [?type (read' id)] (case ?type (#.Some type) (in type) @@ -225,7 +225,7 @@ (def: (bound id) (-> Var (Check Type)) (function (_ context) - (case (|> context (get@ #.var_bindings) (var::get id)) + (case (|> context (value@ #.var_bindings) (var::get id)) (#.Some (#.Some bound)) (#try.Success [context bound]) @@ -240,9 +240,9 @@ "Fails if the variable has been bound already.")} (-> Type Var (Check Any)) (function (_ context) - (case (|> context (get@ #.var_bindings) (var::get id)) + (case (|> context (value@ #.var_bindings) (var::get id)) (#.Some #.None) - (#try.Success [(update@ #.var_bindings (var::put id (#.Some type)) context) + (#try.Success [(revised@ #.var_bindings (var::put id (#.Some type)) context) []]) (#.Some (#.Some bound)) @@ -251,12 +251,12 @@ _ (exception.except ..unknown_type_var id)))) -(def: (update type id) +(def: (re_bind type id) (-> Type Var (Check Any)) (function (_ context) - (case (|> context (get@ #.var_bindings) (var::get id)) + (case (|> context (value@ #.var_bindings) (var::get id)) (#.Some _) - (#try.Success [(update@ #.var_bindings (var::put id (#.Some type)) context) + (#try.Success [(revised@ #.var_bindings (var::put id (#.Some type)) context) []]) _ @@ -266,29 +266,29 @@ {#.doc (example "A brand-new (unbound) type-variable.")} (Check [Var Type]) (function (_ context) - (let [id (get@ #.var_counter context)] + (let [id (value@ #.var_counter context)] (#try.Success [(|> context - (update@ #.var_counter inc) - (update@ #.var_bindings (var::new id))) + (revised@ #.var_counter ++) + (revised@ #.var_bindings (var::new id))) [id (#.Var id)]])))) -(def: (apply_type! funcT argT) +(def: (on argT funcT) (-> Type Type (Check Type)) (case funcT (#.Var func_id) (do ..monad - [?funcT' (read func_id)] + [?funcT' (read' func_id)] (case ?funcT' (#.Some funcT') - (apply_type! funcT' argT) + (on argT funcT') _ (except ..invalid_type_application [funcT argT]))) (#.Apply argT' funcT') (do ..monad - [funcT'' (apply_type! funcT' argT')] - (apply_type! funcT'' argT)) + [funcT'' (on argT' funcT')] + (on argT funcT'')) _ (case (//.applied (list argT) funcT) @@ -311,7 +311,7 @@ (function (_ context) (loop [current start output (set.has start empty_ring)] - (case (|> context (get@ #.var_bindings) (var::get current)) + (case (|> context (value@ #.var_bindings) (var::get current)) (#.Some (#.Some type)) (case type (#.Var post) @@ -362,12 +362,8 @@ (//\= a a'))) assumptions)) -(def: (assume! assumption assumptions) - (-> Assumption (List Assumption) (List Assumption)) - (#.Item assumption assumptions)) - -... TODO: "if_bind" can be optimized... -(def: (if_bind id type then else) +... TODO: "if_can_bind" can be optimized... +(def: (if_can_bind id type then else) (All [a] (-> Var Type (Check a) (-> Type (Check a)) (Check a))) @@ -378,10 +374,10 @@ (do {! ..monad} [ring (..ring id) _ (..assertion "" (n.> 1 (set.size ring))) - _ (monad.map ! (update type) (set.list ring))] + _ (monad.map ! (re_bind type) (set.list ring))] then) (do ..monad - [?bound (read id)] + [?bound (read' id)] (else (maybe.else (#.Var id) ?bound))))) ... TODO: "link/2" can be optimized... @@ -395,8 +391,8 @@ (def: (link/3 interpose to from) (-> Var Var Var (Check Any)) (do ..monad - [_ (update (#.Var interpose) from)] - (update (#.Var to) interpose))) + [_ (re_bind (#.Var interpose) from)] + (re_bind (#.Var to) interpose))) ... TODO: "check_vars" can be optimized... (def: (check_vars check' assumptions idE idA) @@ -457,7 +453,7 @@ [<pattern> (do ! [ring (..ring <id>) - _ (monad.map ! (update <type>) (set.list ring))] + _ (monad.map ! (re_bind <type>) (set.list ring))] (in assumptions))]) ([[(#.Var _) _] idE atype] [[_ (#.Var _)] idA etype]) @@ -482,22 +478,22 @@ [(#.UnivQ _ _) (#.Ex _)] (do ..monad - [expected' (apply_type! expected_function expected_input)] + [expected' (..on expected_input expected_function)] (check' assumptions expected' (#.Apply actual))) [(#.Ex _) (#.UnivQ _ _)] (do ..monad - [actual' (apply_type! actual_function actual_input)] + [actual' (..on actual_input actual_function)] (check' assumptions (#.Apply expected) actual')) [(#.Apply [expected_input' expected_function']) (#.Ex _)] (do ..monad - [expected_function'' (apply_type! expected_function' expected_input')] + [expected_function'' (..on expected_input' expected_function')] (check' assumptions (#.Apply [expected_input expected_function'']) (#.Apply actual))) [(#.Ex _) (#.Apply [actual_input' actual_function'])] (do ..monad - [actual_function'' (apply_type! actual_function' actual_input')] + [actual_function'' (..on actual_input' actual_function')] (check' assumptions (#.Apply expected) (#.Apply [actual_input actual_function'']))) (^or [(#.Ex _) _] [_ (#.Ex _)]) @@ -508,7 +504,7 @@ [(#.Var id) _] (function (_ context) (case ((do ..monad - [expected_function' (..read! id)] + [expected_function' (..read id)] (check' assumptions (#.Apply expected_input expected_function') (#.Apply actual))) context) (#try.Success output) @@ -518,7 +514,7 @@ (case actual_function (#.UnivQ _ _) ((do ..monad - [actual' (apply_type! actual_function actual_input)] + [actual' (..on actual_input actual_function)] (check' assumptions (#.Apply expected) actual')) context) @@ -531,15 +527,15 @@ _ ((do ..monad [assumptions (check' assumptions expected_function actual_function) - expected' (apply_type! actual_function expected_input) - actual' (apply_type! actual_function actual_input)] + expected' (..on expected_input actual_function) + actual' (..on actual_input actual_function)] (check' assumptions expected' actual')) context)))) [_ (#.Var id)] (function (_ context) (case ((do ..monad - [actual_function' (read! id)] + [actual_function' (read id)] (check' assumptions (#.Apply expected) (#.Apply actual_input actual_function'))) context) (#try.Success output) @@ -548,8 +544,8 @@ _ ((do ..monad [assumptions (check' assumptions expected_function actual_function) - expected' (apply_type! expected_function expected_input) - actual' (apply_type! expected_function actual_input)] + expected' (..on expected_input expected_function) + actual' (..on actual_input expected_function)] (check' assumptions expected' actual')) context))) @@ -573,16 +569,16 @@ (check_vars check' assumptions idE idA) [(#.Var id) _] - (if_bind id actual - (check\in assumptions) - (function (_ bound) - (check' assumptions bound actual))) + (if_can_bind id actual + (check\in assumptions) + (function (_ bound) + (check' assumptions bound actual))) [_ (#.Var id)] - (if_bind id expected - (check\in assumptions) - (function (_ bound) - (check' assumptions expected bound))) + (if_can_bind id expected + (check\in assumptions) + (function (_ bound) + (check' assumptions expected bound))) (^template [<fE> <fA>] [[(#.Apply aE <fE>) (#.Apply aA <fA>)] @@ -597,12 +593,12 @@ (if (assumed? new_assumption assumptions) (check\in assumptions) (do ..monad - [expected' (apply_type! F A)] - (check' (assume! new_assumption assumptions) expected' actual)))) + [expected' (..on A F)] + (check' (#.Item new_assumption assumptions) expected' actual)))) [_ (#.Apply A F)] (do ..monad - [actual' (apply_type! F A)] + [actual' (..on A F)] (check' assumptions expected actual')) ... TODO: Refactor-away as cold-code @@ -610,7 +606,7 @@ [[(<tag> _) _] (do ..monad [[_ paramT] <instancer> - expected' (apply_type! expected paramT)] + expected' (..on paramT expected)] (check' assumptions expected' actual))]) ([#.UnivQ ..existential] [#.ExQ ..var]) @@ -620,7 +616,7 @@ [[_ (<tag> _)] (do ..monad [[_ paramT] <instancer> - actual' (apply_type! actual paramT)] + actual' (..on paramT actual)] (check' assumptions expected actual'))]) ([#.UnivQ ..var] [#.ExQ ..existential]) @@ -713,7 +709,7 @@ (#.Var id) (do ..monad - [?actualT (read id)] + [?actualT (read' id)] (case ?actualT (#.Some actualT) (clean actualT) diff --git a/stdlib/source/library/lux/type/implicit.lux b/stdlib/source/library/lux/type/implicit.lux index 99cafdcda..cc54a82a1 100644 --- a/stdlib/source/library/lux/type/implicit.lux +++ b/stdlib/source/library/lux/type/implicit.lux @@ -30,7 +30,7 @@ (def: (type_var id env) (-> Nat Type_Context (Meta Type)) (case (list.example (|>> product.left (n.= id)) - (get@ #.var_bindings env)) + (value@ #.var_bindings env)) (#.Some [_ (#.Some type)]) (case type (#.Var id') @@ -53,7 +53,7 @@ compiler meta.compiler_state] (case raw_type (#.Var id) - (type_var id (get@ #.type_context compiler)) + (type_var id (value@ #.type_context compiler)) _ (in raw_type)))) @@ -75,7 +75,7 @@ (#.Product left right) (if (n.= 0 idx) (\ check.monad in left) - (member_type (dec idx) right)) + (member_type (-- idx) right)) _ (if (n.= 0 idx) @@ -336,7 +336,7 @@ (list.indices 10) (list.indices 10)) "(Functor List) map" - (\\ map inc (list.indices 10)) + (\\ map ++ (list.indices 10)) "Caveat emptor: You need to make sure to import the module of any implementation you want to use." "Otherwise, this macro will not find it.")} (case args @@ -364,7 +364,7 @@ (#.Right [args _]) (do {! meta.monad} - [labels (|> (macro.identifier "") (list.repeated (list.size args)) (monad.seq !))] + [labels (|> (macro.identifier "") (list.repeated (list.size args)) (monad.all !))] (in (list (` (let [(~+ (|> args (list.zipped/2 labels) (list\map ..pair_list) list\join))] (..\\ (~ (code.identifier member)) (~+ labels))))))) )) @@ -373,7 +373,7 @@ (-> Nat (Meta (List Code))) (|> (macro.identifier "g!implicit") (list.repeated amount) - (monad.seq meta.monad))) + (monad.all meta.monad))) (def: implicits (Parser (List Code)) diff --git a/stdlib/source/library/lux/type/poly.lux b/stdlib/source/library/lux/type/poly.lux index edd21a88c..51f0b7618 100644 --- a/stdlib/source/library/lux/type/poly.lux +++ b/stdlib/source/library/lux/type/poly.lux @@ -86,7 +86,7 @@ (let [idx (<type>.adjusted_idx env idx)] (if (n.= 0 idx) (|> (dictionary.value idx env) maybe.trusted product.left (code env)) - (` (.$ (~ (code.nat (dec idx))))))) + (` (.$ (~ (code.nat (-- idx))))))) (#.Apply (#.Named [(~~ (static .prelude_module)) "Nothing"] _) (#.Parameter idx)) (let [idx (<type>.adjusted_idx env idx)] diff --git a/stdlib/source/library/lux/type/quotient.lux b/stdlib/source/library/lux/type/quotient.lux index 0006d9dbd..6334d68f3 100644 --- a/stdlib/source/library/lux/type/quotient.lux +++ b/stdlib/source/library/lux/type/quotient.lux @@ -40,7 +40,7 @@ (template [<name> <output> <slot>] [(def: .public <name> (All [t c %] (-> (Quotient t c %) <output>)) - (|>> :representation (get@ <slot>)))] + (|>> :representation (value@ <slot>)))] [value t #value] [label c #label] diff --git a/stdlib/source/library/lux/type/refinement.lux b/stdlib/source/library/lux/type/refinement.lux index 4e1a88c09..7bb718659 100644 --- a/stdlib/source/library/lux/type/refinement.lux +++ b/stdlib/source/library/lux/type/refinement.lux @@ -34,7 +34,7 @@ (template [<name> <output> <slot>] [(def: .public <name> (All [t %] (-> (Refined t %) <output>)) - (|>> :representation (get@ <slot>)))] + (|>> :representation (value@ <slot>)))] [value t #value] [predicate (Predicate t) #predicate] diff --git a/stdlib/source/library/lux/type/resource.lux b/stdlib/source/library/lux/type/resource.lux index 5ee949bd3..fee4aaf79 100644 --- a/stdlib/source/library/lux/type/resource.lux +++ b/stdlib/source/library/lux/type/resource.lux @@ -55,7 +55,7 @@ (function (_ keys) (\ monad in [keys value]))) - (def: (bind f input) + (def: (then f input) (function (_ keysI) (do monad [[keysT value] (input keysI)] @@ -166,12 +166,12 @@ (#.Item head tail) (do {! meta.monad} [.let [max_idx (list\fold n.max head tail)] - g!inputs (<| (monad.seq !) (list.repeated (inc max_idx)) (macro.identifier "input")) + g!inputs (<| (monad.all !) (list.repeated (++ max_idx)) (macro.identifier "input")) .let [g!outputs (|> (monad.fold maybe.monad (function (_ from to) (do maybe.monad [input (list.item from g!inputs)] - (in (row.add input to)))) + (in (row.suffix input to)))) (: (Row Code) row.empty) swaps) maybe.trusted @@ -210,7 +210,7 @@ (do {! meta.monad} [g!keys (|> (macro.identifier "keys") (list.repeated amount) - (monad.seq !))] + (monad.all !))] (in (list (` (: (All [(~ g!!) (~+ g!keys) (~ g!context)] (-> ((~! monad.Monad) (~ g!!)) (Procedure (~ g!!) diff --git a/stdlib/source/library/lux/type/unit.lux b/stdlib/source/library/lux/type/unit.lux index fcbfe0711..e18af25b0 100644 --- a/stdlib/source/library/lux/type/unit.lux +++ b/stdlib/source/library/lux/type/unit.lux @@ -217,5 +217,5 @@ (All [unit] (Enum (Qty unit))) (def: &order ..order) - (def: succ (|>> ..out inc ..in)) - (def: pred (|>> ..out dec ..in))) + (def: succ (|>> ..out ++ ..in)) + (def: pred (|>> ..out -- ..in))) diff --git a/stdlib/source/library/lux/world/db/jdbc.lux b/stdlib/source/library/lux/world/db/jdbc.lux index 2906cebeb..76c1cc17b 100644 --- a/stdlib/source/library/lux/world/db/jdbc.lux +++ b/stdlib/source/library/lux/world/db/jdbc.lux @@ -92,10 +92,10 @@ (-> java/sql/PreparedStatement (IO (Try a))) (IO (Try a)))) (do (try.with io.monad) - [prepared (io.io (java/sql/Connection::prepareStatement (sql.sql (get@ #sql statement)) + [prepared (io.io (java/sql/Connection::prepareStatement (sql.sql (value@ #sql statement)) (java/sql/Statement::RETURN_GENERATED_KEYS) conn)) - _ (io.io ((get@ #input statement) (get@ #value statement) [1 prepared])) + _ (io.io ((value@ #input statement) (value@ #value statement) [1 prepared])) result (action prepared) _ (java/sql/Statement::close prepared)] (in result))) @@ -114,29 +114,29 @@ (def: .public (connect creds) (-> Credentials (IO (Try (DB IO)))) (do (try.with io.monad) - [connection (java/sql/DriverManager::getConnection (get@ #url creds) - (get@ #user creds) - (get@ #password creds))] + [connection (java/sql/DriverManager::getConnection (value@ #url creds) + (value@ #user creds) + (value@ #password creds))] (in (: (DB IO) (implementation (def: execute (..can_execute (function (execute statement) (with_statement statement connection - (function (_ prepared) - (do (try.with io.monad) - [row_count (java/sql/PreparedStatement::executeUpdate prepared)] - (in (.nat row_count)))))))) + (function (_ prepared) + (do (try.with io.monad) + [row_count (java/sql/PreparedStatement::executeUpdate prepared)] + (in (.nat row_count)))))))) (def: insert (..can_insert (function (insert statement) (with_statement statement connection - (function (_ prepared) - (do (try.with io.monad) - [_ (java/sql/PreparedStatement::executeUpdate prepared) - result_set (io.io (java/sql/Statement::getGeneratedKeys prepared))] - (/output.rows /output.long result_set))))))) + (function (_ prepared) + (do (try.with io.monad) + [_ (java/sql/PreparedStatement::executeUpdate prepared) + result_set (io.io (java/sql/Statement::getGeneratedKeys prepared))] + (/output.rows /output.long result_set))))))) (def: close (..can_close @@ -147,10 +147,10 @@ (..can_query (function (query [statement output]) (with_statement statement connection - (function (_ prepared) - (do (try.with io.monad) - [result_set (java/sql/PreparedStatement::executeQuery prepared)] - (/output.rows output result_set))))))) + (function (_ prepared) + (do (try.with io.monad) + [result_set (java/sql/PreparedStatement::executeQuery prepared)] + (/output.rows output result_set))))))) ))))) (def: .public (with_db creds action) diff --git a/stdlib/source/library/lux/world/db/jdbc/input.lux b/stdlib/source/library/lux/world/db/jdbc/input.lux index fe510ea66..4a2f43507 100644 --- a/stdlib/source/library/lux/world/db/jdbc/input.lux +++ b/stdlib/source/library/lux/world/db/jdbc/input.lux @@ -75,7 +75,7 @@ (function (_ value [idx statement]) (do try.monad [_ (<setter> (.int idx) value statement)] - (in [(.inc idx) statement]))))] + (in [(.++ idx) statement]))))] [boolean Bit java/sql/PreparedStatement::setBoolean] @@ -99,7 +99,7 @@ [_ (<setter> (.int idx) (<constructor> (instant.millis value)) statement)] - (in [(.inc idx) statement]))))] + (in [(.++ idx) statement]))))] [date java/sql/PreparedStatement::setDate java/sql/Date::new] [time java/sql/PreparedStatement::setTime java/sql/Time::new] diff --git a/stdlib/source/library/lux/world/db/jdbc/output.lux b/stdlib/source/library/lux/world/db/jdbc/output.lux index 08c7354f5..e6e9a8306 100644 --- a/stdlib/source/library/lux/world/db/jdbc/output.lux +++ b/stdlib/source/library/lux/world/db/jdbc/output.lux @@ -121,7 +121,7 @@ (#try.Failure error) (#try.Success value) - (#try.Success [(inc idx) value]))))] + (#try.Success [(++ idx) value]))))] [boolean java/sql/ResultSet::getBoolean Bit] @@ -146,7 +146,7 @@ (#try.Failure error) (#try.Success value) - (#try.Success [(inc idx) + (#try.Success [(++ idx) (instant.from_millis (java/util/Date::getTime value))]))))] [date java/sql/ResultSet::getDate] diff --git a/stdlib/source/library/lux/world/file.lux b/stdlib/source/library/lux/world/file.lux index e6c10352f..05925b4e8 100644 --- a/stdlib/source/library/lux/world/file.lux +++ b/stdlib/source/library/lux/world/file.lux @@ -1059,8 +1059,8 @@ [(#.Left file) #.End] (#try.Success (dictionary.has head (#.Left (|> file - (set@ #mock_last_modified now) - (set@ #mock_content content))) + (with@ #mock_last_modified now) + (with@ #mock_content content))) directory)) [(#.Right sub_directory) (#.Item _)] @@ -1239,7 +1239,7 @@ (in (|> |store| (..retrieve_mock_file! separator path) (try\map (|>> product.right - (get@ #mock_content) + (value@ #mock_content) binary.size))))))) (def: (last_modified path) @@ -1249,7 +1249,7 @@ (in (|> |store| (..retrieve_mock_file! separator path) (try\map (|>> product.right - (get@ #mock_last_modified)))))))) + (value@ #mock_last_modified)))))))) (def: (can_execute? path) (stm.commit! @@ -1258,7 +1258,7 @@ (in (|> |store| (..retrieve_mock_file! separator path) (try\map (|>> product.right - (get@ #mock_can_execute)))))))) + (value@ #mock_can_execute)))))))) (def: (read path) (stm.commit! @@ -1267,7 +1267,7 @@ (in (|> |store| (..retrieve_mock_file! separator path) (try\map (|>> product.right - (get@ #mock_content)))))))) + (value@ #mock_content)))))))) (def: (delete path) (stm.commit! @@ -1278,7 +1278,7 @@ (..attempt! (function (_ |store|) (do try.monad [[name file] (..retrieve_mock_file! separator path |store|)] - (..update_mock_file! separator path now (get@ #mock_content file) |store|))) + (..update_mock_file! separator path now (value@ #mock_content file) |store|))) store))) (def: (write content path) @@ -1296,7 +1296,7 @@ [[name file] (..retrieve_mock_file! separator path |store|)] (..update_mock_file! separator path now (\ binary.monoid compose - (get@ #mock_content file) + (value@ #mock_content file) content) |store|))) store)))) @@ -1308,7 +1308,7 @@ (case (do try.monad [[name file] (..retrieve_mock_file! separator origin |store|) |store| (..delete_mock_node! separator origin |store|)] - (..update_mock_file! separator destination (get@ #mock_last_modified file) (get@ #mock_content file) |store|)) + (..update_mock_file! separator destination (value@ #mock_last_modified file) (value@ #mock_content file) |store|)) (#try.Success |store|) (do ! [_ (stm.write |store| store)] diff --git a/stdlib/source/library/lux/world/file/watch.lux b/stdlib/source/library/lux/world/file/watch.lux index 3a0b98f86..0e5deec4a 100644 --- a/stdlib/source/library/lux/world/file/watch.lux +++ b/stdlib/source/library/lux/world/file/watch.lux @@ -56,7 +56,7 @@ (def: .public <predicate> (Predicate Concern) - (|>> :representation (get@ <event>)))] + (|>> :representation (value@ <event>)))] [creation creation? #create true false false] @@ -283,7 +283,7 @@ (loop [idx 0 output #.End] (if (n.< size idx) - (recur (inc idx) + (recur (++ idx) (#.Item (java/util/List::get (.int idx) list) output)) output)))) @@ -365,7 +365,7 @@ (def: (default_start watch_events watcher path) (-> (List Watch_Event) java/nio/file/WatchService //.Path (Async (Try java/nio/file/WatchKey))) (let [watch_events' (list\fold (function (_ [index watch_event] watch_events') - (ffi.array_write index watch_event watch_events')) + (ffi.write! index watch_event watch_events')) (ffi.array (java/nio/file/WatchEvent$Kind java/lang/Object) (list.size watch_events)) (list.enumeration watch_events))] diff --git a/stdlib/source/library/lux/world/net/http/client.lux b/stdlib/source/library/lux/world/net/http/client.lux index 167d87c88..50a5a2436 100644 --- a/stdlib/source/library/lux/world/net/http/client.lux +++ b/stdlib/source/library/lux/world/net/http/client.lux @@ -182,7 +182,7 @@ (#.Some name) (do ! [?value (java/net/URLConnection::getHeaderField index connection)] - (recur (inc index) + (recur (++ index) (dictionary.has name (maybe.else "" ?value) headers))) #.None @@ -232,10 +232,10 @@ async.future (\ async.monad map (|>> (case> (#try.Success [status message]) - (#try.Success [status (update@ #//.body (: (-> (//.Body IO) (//.Body Async)) - (function (_ body) - (|>> body async.future))) - message)]) + (#try.Success [status (revised@ #//.body (: (-> (//.Body IO) (//.Body Async)) + (function (_ body) + (|>> body async.future))) + message)]) (#try.Failure error) (#try.Failure error))))))) diff --git a/stdlib/source/library/lux/world/net/http/request.lux b/stdlib/source/library/lux/world/net/http/request.lux index 6d9e94b8e..5b0a254e4 100644 --- a/stdlib/source/library/lux/world/net/http/request.lux +++ b/stdlib/source/library/lux/world/net/http/request.lux @@ -56,7 +56,7 @@ (All [a] (-> (<json>.Reader a) (-> a Server) Server)) (function (_ (^@ request [identification protocol resource message])) (do async.monad - [?raw (read_text_body (get@ #//.body message))] + [?raw (read_text_body (value@ #//.body message))] (case (do try.monad [raw ?raw content (\ json.codec decode raw)] @@ -71,7 +71,7 @@ (-> (-> Text Server) Server) (function (_ (^@ request [identification protocol resource message])) (do async.monad - [?raw (read_text_body (get@ #//.body message))] + [?raw (read_text_body (value@ #//.body message))] (case ?raw (#try.Success content) (server content request) @@ -82,14 +82,14 @@ (def: .public (query property server) (All [a] (-> (Property a) (-> a Server) Server)) (function (_ [identification protocol resource message]) - (let [full (get@ #//.uri resource) + (let [full (value@ #//.uri resource) [uri query] (|> full (text.split_by "?") (maybe.else [full ""]))] (case (do try.monad [query (//query.parameters query) input (context.result query property)] - (in [[identification protocol (set@ #//.uri uri resource) message] + (in [[identification protocol (with@ #//.uri uri resource) message] input])) (#try.Success [request input]) (server input request) @@ -101,7 +101,7 @@ (All [a] (-> (Property a) (-> a Server) Server)) (function (_ (^@ request [identification protocol resource message])) (do async.monad - [?body (read_text_body (get@ #//.body message))] + [?body (read_text_body (value@ #//.body message))] (case (do try.monad [body ?body form (//query.parameters body)] @@ -116,7 +116,7 @@ (All [a] (-> (Property a) (-> a Server) Server)) (function (_ (^@ request [identification protocol resource message])) (case (do try.monad - [cookies (|> (get@ #//.headers message) + [cookies (|> (value@ #//.headers message) (dictionary.value "Cookie") (maybe.else "") //cookie.get)] diff --git a/stdlib/source/library/lux/world/net/http/response.lux b/stdlib/source/library/lux/world/net/http/response.lux index 9d74ced0c..b49715c4d 100644 --- a/stdlib/source/library/lux/world/net/http/response.lux +++ b/stdlib/source/library/lux/world/net/http/response.lux @@ -40,7 +40,7 @@ (def: .public (temporary_redirect to) (-> URL Response) (let [[status message] (..empty status.temporary_redirect)] - [status (update@ #//.headers (header.location to) message)])) + [status (revised@ #//.headers (header.location to) message)])) (def: .public not_found Response diff --git a/stdlib/source/library/lux/world/net/http/route.lux b/stdlib/source/library/lux/world/net/http/route.lux index a650f53d2..9689e3414 100644 --- a/stdlib/source/library/lux/world/net/http/route.lux +++ b/stdlib/source/library/lux/world/net/http/route.lux @@ -18,7 +18,7 @@ [(def: .public (<name> server) (-> Server Server) (function (_ (^@ request [identification protocol resource message])) - (case (get@ #//.scheme protocol) + (case (value@ #//.scheme protocol) <scheme> (server request) @@ -33,7 +33,7 @@ [(def: .public (<name> server) (-> Server Server) (function (_ (^@ request [identification protocol resource message])) - (case (get@ #//.method resource) + (case (value@ #//.method resource) <method> (server request) @@ -54,12 +54,12 @@ (def: .public (uri path server) (-> URI Server Server) (function (_ [identification protocol resource message]) - (if (text.starts_with? path (get@ #//.uri resource)) + (if (text.starts_with? path (value@ #//.uri resource)) (server [identification protocol - (update@ #//.uri - (|>> (text.clip' (text.size path)) maybe.trusted) - resource) + (revised@ #//.uri + (|>> (text.clip' (text.size path)) maybe.trusted) + resource) message]) (async.resolved //response.not_found)))) diff --git a/stdlib/source/library/lux/world/service/journal.lux b/stdlib/source/library/lux/world/service/journal.lux index 424288cb5..afab93a3e 100644 --- a/stdlib/source/library/lux/world/service/journal.lux +++ b/stdlib/source/library/lux/world/service/journal.lux @@ -33,12 +33,12 @@ (implementation: .public (equivalence (^open "_\.")) (All [a] (-> (Equivalence a) (Equivalence (Entry a)))) (def: (= reference sample) - (and (_\= (get@ #what reference) (get@ #what sample)) - (text\= (get@ #why reference) (get@ #why sample)) - (text\= (get@ #how reference) (get@ #how sample)) - (text\= (get@ #who reference) (get@ #who sample)) - (text\= (get@ #where reference) (get@ #where sample)) - (instant\= (get@ #when reference) (get@ #when sample))))) + (and (_\= (value@ #what reference) (value@ #what sample)) + (text\= (value@ #why reference) (value@ #why sample)) + (text\= (value@ #how reference) (value@ #how sample)) + (text\= (value@ #who reference) (value@ #who sample)) + (text\= (value@ #where reference) (value@ #where sample)) + (instant\= (value@ #when reference) (value@ #when sample))))) (capability: .public (Can_Write ! a) (can_write (Entry a) (! (Try Any)))) diff --git a/stdlib/source/library/lux/world/shell.lux b/stdlib/source/library/lux/world/shell.lux index 429c46897..d59b72786 100644 --- a/stdlib/source/library/lux/world/shell.lux +++ b/stdlib/source/library/lux/world/shell.lux @@ -182,9 +182,9 @@ (-> (List Argument) (Array java/lang/String)) (product.right (list\fold (function (_ argument [idx output]) - [(inc idx) (jvm.array_write idx - (:as java/lang/String argument) - output)]) + [(++ idx) (jvm.write! idx + (:as java/lang/String argument) + output)]) [0 (jvm.array java/lang/String (list.size arguments))] arguments))) @@ -197,9 +197,10 @@ (java/util/Map java/lang/String java/lang/String) (java/util/Map java/lang/String java/lang/String)) (list\fold (function (_ [key value] target') - (exec (java/util/Map::put (:as java/lang/String key) - (:as java/lang/String value) - target') + (exec + (java/util/Map::put (:as java/lang/String key) + (:as java/lang/String value) + target') target')) target (dictionary.entries input))) diff --git a/stdlib/source/poly/lux/abstract/equivalence.lux b/stdlib/source/poly/lux/abstract/equivalence.lux index b311d97ec..bcb2574bc 100644 --- a/stdlib/source/poly/lux/abstract/equivalence.lux +++ b/stdlib/source/poly/lux/abstract/equivalence.lux @@ -108,7 +108,7 @@ ... Variants (do ! [members (<type>.variant (<>.many equivalence)) - .let [last (dec (list.size members)) + .let [last (-- (list.size members)) g!_ (code.local_identifier "_____________") g!left (code.local_identifier "_____________left") g!right (code.local_identifier "_____________right")]] @@ -117,8 +117,8 @@ (case [(~ g!left) (~ g!right)] (~+ (list\join (list\map (function (_ [tag g!eq]) (if (nat.= last tag) - (list (` [((~ (code.nat (dec tag))) #1 (~ g!left)) - ((~ (code.nat (dec tag))) #1 (~ g!right))]) + (list (` [((~ (code.nat (-- tag))) #1 (~ g!left)) + ((~ (code.nat (-- tag))) #1 (~ g!right))]) (` ((~ g!eq) (~ g!left) (~ g!right)))) (list (` [((~ (code.nat tag)) #0 (~ g!left)) ((~ (code.nat tag)) #0 (~ g!right))]) diff --git a/stdlib/source/poly/lux/abstract/functor.lux b/stdlib/source/poly/lux/abstract/functor.lux index 57f047798..d68d55af8 100644 --- a/stdlib/source/poly/lux/abstract/functor.lux +++ b/stdlib/source/poly/lux/abstract/functor.lux @@ -38,7 +38,7 @@ (function (_ unwrappedT) (if (n.= 1 num_vars) (` ((~! /.Functor) (~ (poly.code *env* unwrappedT)))) - (let [paramsC (|> num_vars dec list.indices (list\map (|>> %.nat code.local_identifier)))] + (let [paramsC (|> num_vars -- list.indices (list\map (|>> %.nat code.local_identifier)))] (` (All [(~+ paramsC)] ((~! /.Functor) ((~ (poly.code *env* unwrappedT)) (~+ paramsC))))))))) Arg<?> (: (-> Code (<type>.Parser Code)) @@ -46,19 +46,19 @@ ($_ p.either ... Type-var (do p.monad - [.let [varI (|> num_vars (n.* 2) dec)] + [.let [varI (|> num_vars (n.* 2) --)] _ (<type>.parameter! varI)] (in (` ((~ funcC) (~ valueC))))) ... Variants (do ! [_ (in []) membersC (<type>.variant (p.many (Arg<?> valueC))) - .let [last (dec (list.size membersC))]] + .let [last (-- (list.size membersC))]] (in (` (case (~ valueC) (~+ (list\join (list\map (function (_ [tag memberC]) (if (n.= last tag) - (list (` ((~ (code.nat (dec tag))) #1 (~ valueC))) - (` ((~ (code.nat (dec tag))) #1 (~ memberC)))) + (list (` ((~ (code.nat (-- tag))) #1 (~ valueC))) + (` ((~ (code.nat (-- tag))) #1 (~ memberC)))) (list (` ((~ (code.nat tag)) #0 (~ valueC))) (` ((~ (code.nat tag)) #0 (~ memberC)))))) (list.enumeration membersC)))))))) @@ -72,7 +72,7 @@ (do ! [_ (in []) memberC (Arg<?> slotC)] - (recur (inc idx) + (recur (++ idx) (list\compose pairsCC (list [slotC memberC]))))) (in pairsCC)))))] (in (` (case (~ valueC) diff --git a/stdlib/source/poly/lux/data/format/json.lux b/stdlib/source/poly/lux/data/format/json.lux index 42f0ed7d8..1496026a7 100644 --- a/stdlib/source/poly/lux/data/format/json.lux +++ b/stdlib/source/poly/lux/data/format/json.lux @@ -51,7 +51,7 @@ (function (_ input) (non_rec (rec_encode non_rec) input))) -(def: low_mask Nat (|> 1 (i64.left_shifted 32) dec)) +(def: low_mask Nat (|> 1 (i64.left_shifted 32) --)) (def: high_mask Nat (|> low_mask (i64.left_shifted 32))) (implementation: nat_codec @@ -166,14 +166,14 @@ [.let [g!_ (code.local_identifier "_______") g!input (code.local_identifier "_______input")] members (<type>.variant (<>.many encode)) - .let [last (dec (list.size members))]] + .let [last (-- (list.size members))]] (in (` (: (~ (@JSON\encode inputT)) (function ((~ g!_) (~ g!input)) (case (~ g!input) (~+ (list\join (list\map (function (_ [tag g!encode]) (if (n.= last tag) - (.list (` ((~ (code.nat (dec tag))) #1 (~ g!input))) - (` ((~! /.json) [(~ (code.frac (..tag (dec tag)))) + (.list (` ((~ (code.nat (-- tag))) #1 (~ g!input))) + (` ((~! /.json) [(~ (code.frac (..tag (-- tag)))) #1 ((~ g!encode) (~ g!input))]))) (.list (` ((~ (code.nat tag)) #0 (~ g!input))) @@ -278,14 +278,14 @@ ((~! </>.array) ((~! <>.some) (~ subC))))))) (do ! [members (<type>.variant (<>.many decode)) - .let [last (dec (list.size members))]] + .let [last (-- (list.size members))]] (in (` (: (~ (@JSON\decode inputT)) ($_ ((~! <>.or)) (~+ (list\map (function (_ [tag memberC]) (if (n.= last tag) (` (|> (~ memberC) ((~! <>.after) ((~! </>.boolean!) (~ (code.bit #1)))) - ((~! <>.after) ((~! </>.number!) (~ (code.frac (..tag (dec tag)))))) + ((~! <>.after) ((~! </>.number!) (~ (code.frac (..tag (-- tag)))))) ((~! </>.array)))) (` (|> (~ memberC) ((~! <>.after) ((~! </>.boolean!) (~ (code.bit #0)))) diff --git a/stdlib/source/program/aedifex.lux b/stdlib/source/program/aedifex.lux index 05aee240b..4dd110551 100644 --- a/stdlib/source/program/aedifex.lux +++ b/stdlib/source/program/aedifex.lux @@ -66,7 +66,7 @@ (def: repositories (-> /.Profile (List (Repository Async))) - (|>> (get@ #/.repositories) + (|>> (value@ #/.repositories) set.list (list\map (|>> (/repository/remote.repository http.default #.None) /repository.async)))) @@ -165,20 +165,21 @@ (#/cli.Deploy repository identity) (..command - (case [(get@ #/.identity profile) - (dictionary.value repository (get@ #/.deploy_repositories profile))] - [(#.Some artifact) (#.Some repository)] - (/command/deploy.do! console - (/repository.async (/repository/remote.repository http.default (#.Some identity) repository)) - (file.async file.default) - artifact - profile) - - [#.None _] - (async\in (exception.except /.no_identity [])) - - [_ #.None] - (async\in (exception.except ..cannot_find_repository [repository (get@ #/.deploy_repositories profile)])))) + (case (value@ #/.identity profile) + (#.Some artifact) + (case (dictionary.value repository (value@ #/.deploy_repositories profile)) + (#.Some repository) + (/command/deploy.do! console + (/repository.async (/repository/remote.repository http.default (#.Some identity) repository)) + (file.async file.default) + artifact + profile) + + #.None + (async\in (exception.except ..cannot_find_repository [repository (value@ #/.deploy_repositories profile)]))) + + #.None + (async\in (exception.except /.no_identity [])))) #/cli.Dependencies (..command @@ -207,8 +208,5 @@ (..command (case auto #/cli.Build (..with_dependencies program console (/command/auto.do! /command/auto.delay watcher /command/build.do!) profile) - #/cli.Test (..with_dependencies program console (/command/auto.do! /command/auto.delay watcher /command/test.do!) profile))))) - - _ - (undefined))) + #/cli.Test (..with_dependencies program console (/command/auto.do! /command/auto.delay watcher /command/test.do!) profile))))))) )))))) diff --git a/stdlib/source/program/aedifex/artifact.lux b/stdlib/source/program/aedifex/artifact.lux index cd53db5c4..6fd2d495f 100644 --- a/stdlib/source/program/aedifex/artifact.lux +++ b/stdlib/source/program/aedifex/artifact.lux @@ -1,6 +1,6 @@ (.module: [library - [lux (#- Name) + [lux (#- Name local) [abstract [equivalence (#+ Equivalence)] [order (#+ Order)] @@ -49,18 +49,18 @@ ..equivalence) (def: (< reference subject) - (<| (or (text\< (get@ #group reference) - (get@ #group subject))) + (<| (or (text\< (value@ #group reference) + (value@ #group subject))) - (and (text\= (get@ #group reference) - (get@ #group subject))) - (or (text\< (get@ #name reference) - (get@ #name subject))) + (and (text\= (value@ #group reference) + (value@ #group subject))) + (or (text\< (value@ #name reference) + (value@ #name subject))) - (and (text\= (get@ #name reference) - (get@ #name subject))) - (text\< (get@ #version reference) - (get@ #version subject))))) + (and (text\= (value@ #name reference) + (value@ #name subject))) + (text\< (value@ #version reference) + (value@ #version subject))))) (template [<separator> <definition>] [(def: <definition> @@ -74,13 +74,13 @@ (def: .public (identity artifact) (-> Artifact Text) - (%.format (get@ #name artifact) + (%.format (value@ #name artifact) ..version_separator - (get@ #version artifact))) + (value@ #version artifact))) (def: .public (format value) (Format Artifact) - (%.format (get@ #group value) + (%.format (value@ #group value) ..identity_separator (..identity value))) @@ -93,16 +93,16 @@ (def: .public (uri version artifact) (-> Version Artifact URI) (let [/ uri.separator - group (..directory / (get@ #group artifact)) - name (get@ #name artifact) - ... version (get@ #version artifact) + group (..directory / (value@ #group artifact)) + name (value@ #name artifact) + ... version (value@ #version artifact) identity (..identity artifact)] (%.format group / name / version / identity))) (def: .public (local artifact) (-> Artifact (List Text)) (list\compose (|> artifact - (get@ #group) + (value@ #group) (text.all_split_by ..group_separator)) - (list (get@ #name artifact) - (get@ #version artifact)))) + (list (value@ #name artifact) + (value@ #version artifact)))) diff --git a/stdlib/source/program/aedifex/command/auto.lux b/stdlib/source/program/aedifex/command/auto.lux index 805ffb1ba..0a1998730 100644 --- a/stdlib/source/program/aedifex/command/auto.lux +++ b/stdlib/source/program/aedifex/command/auto.lux @@ -33,7 +33,7 @@ (\ ! map (|>> (try.else (list)) (monad.map ! (targets fs)))) (\ ! join) - (\ ! map (|>> list.joined (list& path)))))) + (\ ! map (|>> list.together (list& path)))))) (def: .public delay Nat @@ -41,7 +41,7 @@ (def: (pause delay) (-> Nat (Async (Try Any))) - (async.delayed delay (#try.Success []))) + (async.after delay (#try.Success []))) (def: .public (do! delay watcher command) (All [a] @@ -53,10 +53,10 @@ (with_expansions [<call> ((command console program fs shell resolution) profile)] (do {! async.monad} [targets (|> profile - (get@ #///.sources) + (value@ #///.sources) set.list (monad.map ! (..targets fs)) - (\ ! map list.joined))] + (\ ! map list.together))] (do {! ///action.monad} [_ (monad.map ! (\ watcher start watch.modification) targets) _ <call>] diff --git a/stdlib/source/program/aedifex/command/build.lux b/stdlib/source/program/aedifex/command/build.lux index ff469d896..e4de9ab0a 100644 --- a/stdlib/source/program/aedifex/command/build.lux +++ b/stdlib/source/program/aedifex/command/build.lux @@ -49,8 +49,8 @@ (-> Group Name Finder) (|>> dictionary.entries (list.one (function (_ [dependency package]) - (if (and (text\= group (get@ [#///dependency.artifact #///artifact.group] dependency)) - (text\= name (get@ [#///dependency.artifact #///artifact.name] dependency))) + (if (and (text\= group (value@ [#///dependency.artifact #///artifact.group] dependency)) + (text\= name (value@ [#///dependency.artifact #///artifact.name] dependency))) (#.Some dependency) #.None))))) @@ -111,17 +111,17 @@ (def: (path fs home dependency) (All [!] (-> (file.System !) Path Dependency Path)) (let [/ (\ fs separator) - artifact (get@ #///dependency.artifact dependency)] + artifact (value@ #///dependency.artifact dependency)] (|> artifact - (///local.uri (get@ #///artifact.version artifact)) + (///local.uri (value@ #///artifact.version artifact)) (text.replaced uri.separator /) (format home /) - (text.suffix (format "." (get@ #///dependency.type dependency)))))) + (text.suffix (format "." (value@ #///dependency.type dependency)))))) (def: (libraries fs home) (All [!] (-> (file.System !) Path Resolution (List Path))) (|>> dictionary.keys - (list.only (|>> (get@ #///dependency.type) + (list.only (|>> (value@ #///dependency.type) (text\= ///artifact/type.lux_library))) (list\map (..path fs home)))) @@ -156,14 +156,14 @@ (def: .public (host_dependencies fs home) (All [!] (-> (file.System !) Path Resolution (List Path))) (|>> dictionary.keys - (list.only (|>> (get@ #///dependency.type) + (list.only (|>> (value@ #///dependency.type) (text\= ///artifact/type.lux_library) not)) (list\fold (function (_ dependency uniques) - (let [artifact (get@ #///dependency.artifact dependency) - identity [(get@ #///artifact.group artifact) - (get@ #///artifact.name artifact)] - version (get@ #///artifact.version artifact)] + (let [artifact (value@ #///dependency.artifact dependency) + identity [(value@ #///artifact.group artifact) + (value@ #///artifact.name artifact)] + version (value@ #///artifact.version artifact)] (case (dictionary.value identity uniques) (#.Some [current_version current_path]) (if (\ version_order < version current_version) @@ -183,7 +183,7 @@ (def: (plural name) (-> Text (List Text) (List Text)) - (|>> (list\map (|>> (list name))) list.joined)) + (|>> (list\map (|>> (list name))) list.together)) (def: .public start "[BUILD STARTED]") (def: .public success "[BUILD ENDED]") @@ -245,8 +245,7 @@ (-> (List Path) Text) (|> host_dependencies (#.Item ".") - (text.interposed ..jvm_class_path_separator) - %.text)) + (text.interposed ..jvm_class_path_separator))) (def: .public (with_jvm_class_path host_dependencies runtime) (-> (List Path) ///runtime.Runtime ///runtime.Runtime) @@ -255,15 +254,15 @@ runtime _ - (update@ #///runtime.parameters - (|>> (list& "-classpath" (..jvm_class_path host_dependencies))) - runtime))) + (revised@ #///runtime.parameters + (|>> (list& "-cp" (..jvm_class_path host_dependencies))) + runtime))) (def: .public (do! console program fs shell resolution) (-> (Console Async) (Program Async) (file.System Async) (Shell Async) Resolution (Command [Exit Compiler Path])) (function (_ profile) - (let [target (get@ #///.target profile)] - (case (get@ #///.program profile) + (let [target (value@ #///.target profile)] + (case (value@ #///.program profile) #.None (async\in (exception.except ..no_specified_program [])) @@ -273,19 +272,20 @@ .let [home (\ program home) working_directory (\ program directory)]] (do ///action.monad - [[resolution compiler] (async\in (..compiler resolution (get@ #///.compiler profile))) + [[resolution compiler] (async\in (..compiler resolution (value@ #///.compiler profile))) .let [host_dependencies (..host_dependencies fs home resolution) [[command compiler_params] output] (case compiler (#JVM dependency) - [(|> (..path fs home dependency) - (///runtime.for (get@ #///.java profile)) - (with_jvm_class_path host_dependencies)) + [(|> (value@ #///.java profile) + (with@ #///runtime.parameters (list "program._")) + (with_jvm_class_path (#.Item (..path fs home dependency) host_dependencies))) "program.jar"] (^template [<tag> <runtime> <program>] [(<tag> dependency) - [(///runtime.for (get@ <runtime> profile) - (..path fs home dependency)) + [(|> dependency + (..path fs home) + (///runtime.for (value@ <runtime> profile))) <program>]]) ([#JS #///.js "program.js"] [#Python #///.java "program.py"] @@ -294,13 +294,13 @@ / (\ fs separator) cache_directory (format working_directory / target)] _ (console.write_line ..start console) - .let [full_parameters (list.joined (list compiler_params - (list "build") - (..plural "--library" (..libraries fs home resolution)) - (..plural "--host_dependency" host_dependencies) - (..plural "--source" (set.list (get@ #///.sources profile))) - (..singular "--target" cache_directory) - (..singular "--module" program_module)))] + .let [full_parameters (list.together (list compiler_params + (list "build") + (..plural "--library" (..libraries fs home resolution)) + (..plural "--host_dependency" host_dependencies) + (..plural "--source" (set.list (value@ #///.sources profile))) + (..singular "--target" cache_directory) + (..singular "--module" program_module)))] process (\ shell execute [environment working_directory command diff --git a/stdlib/source/program/aedifex/command/clean.lux b/stdlib/source/program/aedifex/command/clean.lux index 67d539db7..9e55ccc83 100644 --- a/stdlib/source/program/aedifex/command/clean.lux +++ b/stdlib/source/program/aedifex/command/clean.lux @@ -33,7 +33,7 @@ (def: .public (do! console fs profile) (-> (Console Async) (file.System Async) (Command Any)) (do {! async.monad} - [.let [target (get@ #///.target profile)] + [.let [target (value@ #///.target profile)] ? (\ fs directory? target) _ (let [! ///action.monad] (if ? diff --git a/stdlib/source/program/aedifex/command/deploy.lux b/stdlib/source/program/aedifex/command/deploy.lux index cbddc9b27..38f975939 100644 --- a/stdlib/source/program/aedifex/command/deploy.lux +++ b/stdlib/source/program/aedifex/command/deploy.lux @@ -60,7 +60,7 @@ (-> (Console Async) (Repository Async) (file.System Async) Artifact (Command Any)) (do {! ///action.monad} [library (|> profile - (get@ #/.sources) + (value@ #/.sources) set.list (export.library fs) (\ ! map (binary.result tar.writer))) diff --git a/stdlib/source/program/aedifex/command/deps.lux b/stdlib/source/program/aedifex/command/deps.lux index 3cbb82403..3c8381e51 100644 --- a/stdlib/source/program/aedifex/command/deps.lux +++ b/stdlib/source/program/aedifex/command/deps.lux @@ -33,16 +33,16 @@ (def: format (%.Format Dependency) - (|>> (get@ #///dependency.artifact) + (|>> (value@ #///dependency.artifact) ///artifact.format %.text)) (def: .public (do! console local remotes new_repository profile) (-> (Console Async) (Repository Async) (List (Repository Async)) (-> URL (Repository Async)) (Command Resolution)) (do async.monad - [.let [dependencies (|> (get@ #///.dependencies profile) + [.let [dependencies (|> (value@ #///.dependencies profile) set.list - (#.Item (get@ #///.compiler profile)))] + (#.Item (value@ #///.compiler profile)))] [local_successes local_failures cache] (///dependency/resolution.all console (list local) new_repository diff --git a/stdlib/source/program/aedifex/command/install.lux b/stdlib/source/program/aedifex/command/install.lux index 9b06daaec..f0677afc7 100644 --- a/stdlib/source/program/aedifex/command/install.lux +++ b/stdlib/source/program/aedifex/command/install.lux @@ -51,11 +51,11 @@ (def: .public (do! console fs repository profile) (-> (Console Async) (file.System Async) (Repository Async) (Command Any)) - (case (get@ #/.identity profile) + (case (value@ #/.identity profile) (#.Some identity) (do ///action.monad [package (|> profile - (get@ #/.sources) + (value@ #/.sources) set.list (export.library fs)) pom (|> profile diff --git a/stdlib/source/program/aedifex/command/test.lux b/stdlib/source/program/aedifex/command/test.lux index a7279c5ec..ae627bcb7 100644 --- a/stdlib/source/program/aedifex/command/test.lux +++ b/stdlib/source/program/aedifex/command/test.lux @@ -36,7 +36,7 @@ (do {! ///action.monad} [.let [home (\ program home)] [build_exit compiler program] (//build.do! console program fs shell resolution - (set@ #///.program (get@ #///.test profile) profile))] + (with@ #///.program (value@ #///.test profile) profile))] (if (i.= shell.normal build_exit) (do ! [_ (console.write_line ..start console) @@ -44,15 +44,14 @@ [test_command test_parameters] (case compiler (#//build.JVM dependency) (|> program - (///runtime.for (get@ #///.java profile)) + (///runtime.for (value@ #///.java profile)) (//build.with_jvm_class_path host_dependencies)) (^template [<tag> <runtime>] [(<tag> artifact) - (///runtime.for (get@ <runtime> profile) + (///runtime.for (value@ <runtime> profile) program)]) - ([#//build.JVM #///.java] - [#//build.JS #///.js] + ([#//build.JS #///.js] [#//build.Python #///.python] [#//build.Lua #///.lua] [#//build.Ruby #///.ruby]))] diff --git a/stdlib/source/program/aedifex/dependency.lux b/stdlib/source/program/aedifex/dependency.lux index f31f0ca44..b1a23c0de 100644 --- a/stdlib/source/program/aedifex/dependency.lux +++ b/stdlib/source/program/aedifex/dependency.lux @@ -35,10 +35,10 @@ ..equivalence) (def: (< reference subject) - (<| (or (//\< (get@ #artifact reference) - (get@ #artifact subject))) + (<| (or (//\< (value@ #artifact reference) + (value@ #artifact subject))) - (and (//\= (get@ #artifact reference) - (get@ #artifact subject))) - (text\< (get@ #type reference) - (get@ #type subject))))) + (and (//\= (value@ #artifact reference) + (value@ #artifact subject))) + (text\< (value@ #type reference) + (value@ #type subject))))) diff --git a/stdlib/source/program/aedifex/dependency/deployment.lux b/stdlib/source/program/aedifex/dependency/deployment.lux index d23e4a805..0e9ab0def 100644 --- a/stdlib/source/program/aedifex/dependency/deployment.lux +++ b/stdlib/source/program/aedifex/dependency/deployment.lux @@ -91,39 +91,39 @@ (do try.monad [now (: (Try ///artifact/time.Time) (///artifact/time.of_instant now)) - .let [version_template (get@ #///artifact.version artifact) + .let [version_template (value@ #///artifact.version artifact) snapshot (|> snapshot - (update@ [#///metadata/snapshot.versioning #///artifact/versioning.snapshot] - (function (_ snapshot) - (case snapshot - #///artifact/snapshot.Local - #///artifact/snapshot.Local - - (#///artifact/snapshot.Remote [_ build]) - (#///artifact/snapshot.Remote [now (inc build)])))) - (set@ [#///metadata/snapshot.versioning #///artifact/versioning.last_updated] now)) - versioning_snapshot (get@ [#///metadata/snapshot.versioning #///artifact/versioning.snapshot] snapshot)]] + (revised@ [#///metadata/snapshot.versioning #///artifact/versioning.snapshot] + (function (_ snapshot) + (case snapshot + #///artifact/snapshot.Local + #///artifact/snapshot.Local + + (#///artifact/snapshot.Remote [_ build]) + (#///artifact/snapshot.Remote [now (++ build)])))) + (with@ [#///metadata/snapshot.versioning #///artifact/versioning.last_updated] now)) + versioning_snapshot (value@ [#///metadata/snapshot.versioning #///artifact/versioning.snapshot] snapshot)]] (in (|> snapshot - (set@ [#///metadata/snapshot.versioning #///artifact/versioning.versions] - (list {#///artifact/snapshot/version.extension type - #///artifact/snapshot/version.value (///artifact/snapshot/version/value.format - {#///artifact/snapshot/version/value.version version_template - #///artifact/snapshot/version/value.snapshot versioning_snapshot}) - #///artifact/snapshot/version.updated now})) - ... (set@ [#///metadata/snapshot.versioning #///artifact/versioning.snapshot] - ... (list\compose (..artifacts type (product.right (get@ #///package.library package))) - ... (..artifacts ///artifact/type.pom (product.right (get@ #///package.pom package))))) + (with@ [#///metadata/snapshot.versioning #///artifact/versioning.versions] + (list {#///artifact/snapshot/version.extension type + #///artifact/snapshot/version.value (///artifact/snapshot/version/value.format + {#///artifact/snapshot/version/value.version version_template + #///artifact/snapshot/version/value.snapshot versioning_snapshot}) + #///artifact/snapshot/version.updated now})) + ... (with@ [#///metadata/snapshot.versioning #///artifact/versioning.snapshot] + ... (list\compose (..artifacts type (product.right (value@ #///package.library package))) + ... (..artifacts ///artifact/type.pom (product.right (value@ #///package.pom package))))) )))) (def: .public (one repository [artifact type] package) (-> (Repository Async) Dependency Package (Async (Try Artifact))) (do {! async.monad} [now (async.future instant.now) - .let [version_template (get@ #///artifact.version artifact)]] + .let [version_template (value@ #///artifact.version artifact)]] (do (try.with !) - [_ (with_status repository version_template [artifact type] (get@ #///package.library package)) + [_ (with_status repository version_template [artifact type] (value@ #///package.library package)) - _ (let [[pom pom_data status] (get@ #///package.pom package)] + _ (let [[pom pom_data status] (value@ #///package.pom package)] (with_status repository version_template [artifact ///artifact/type.pom] @@ -135,8 +135,8 @@ _ (///metadata/snapshot.write repository artifact snapshot) project (///metadata/artifact.read repository artifact) _ (|> project - (set@ #///metadata/artifact.versions (list version_template)) - (set@ #///metadata/artifact.last_updated now) + (with@ #///metadata/artifact.versions (list version_template)) + (with@ #///metadata/artifact.last_updated now) (///metadata/artifact.write repository artifact))] (in artifact)))) diff --git a/stdlib/source/program/aedifex/dependency/resolution.lux b/stdlib/source/program/aedifex/dependency/resolution.lux index 22778e25b..73c5f6608 100644 --- a/stdlib/source/program/aedifex/dependency/resolution.lux +++ b/stdlib/source/program/aedifex/dependency/resolution.lux @@ -1,6 +1,7 @@ (.module: [library [lux (#- Name) + ["@" target] ["." debug] ["." ffi (#+ import:)] [abstract @@ -83,9 +84,10 @@ (case ?actual (#try.Success actual) (in (do {! try.monad} - [output (\ ! map (|>> (:as java/lang/String) - java/lang/String::trim - (:as Text)) + [output (\ ! map (for {@.old (|>> (:as java/lang/String) + java/lang/String::trim + (:as Text)) + @.jvm (|>> java/lang/String::trim)}) (\ utf8.codec decode actual)) actual (|> output (text.all_split_by " ") @@ -113,10 +115,10 @@ [(#.Some sha-1) (#.Some md5)] (#//status.Verified sha-1 md5) - [(#.Some sha-1) _] + [(#.Some sha-1) #.None] (#//status.Partial (#.Left sha-1)) - [_ (#.Some md5)] + [#.None (#.Some md5)] (#//status.Partial (#.Right md5)) [#.None #.None] @@ -128,10 +130,10 @@ extension (///artifact/extension.extension type)] (do (try.with async.monad) [snapshot (///metadata/snapshot.read repository artifact) - .let [version_template (get@ [#///metadata/snapshot.artifact #///artifact.version] snapshot) + .let [version_template (value@ [#///metadata/snapshot.artifact #///artifact.version] snapshot) artifact_version (value.format {#value.version version_template - #value.snapshot (get@ [#///metadata/snapshot.versioning #///artifact/versioning.snapshot] snapshot)}) - artifact (set@ #///artifact.version artifact_version artifact)] + #value.snapshot (value@ [#///metadata/snapshot.versioning #///artifact/versioning.snapshot] snapshot)}) + artifact (with@ #///artifact.version artifact_version artifact)] [pom_data pom_status] (..hashed repository version_template artifact ///artifact/extension.pom) library_&_status (..hashed repository version_template artifact extension)] (\ async.monad in @@ -156,8 +158,8 @@ (exception: .public (cannot_resolve {dependency Dependency}) (exception.report - ["Artifact" (%.text (///artifact.format (get@ #//.artifact dependency)))] - ["Type" (%.text (get@ #//.type dependency))])) + ["Artifact" (%.text (///artifact.format (value@ #//.artifact dependency)))] + ["Type" (%.text (value@ #//.type dependency))])) (template [<sigil> <name> <doing> <at>] [(def: (<name> console repository artifact) @@ -184,17 +186,17 @@ (#.Item repository alternatives) (do {! async.monad} - [_ (..announce_fetching console repository (get@ #//.artifact dependency)) + [_ (..announce_fetching console repository (value@ #//.artifact dependency)) outcome (..one repository dependency)] (case outcome (#try.Success package) (do ! - [_ (..announce_success console repository (get@ #//.artifact dependency))] + [_ (..announce_success console repository (value@ #//.artifact dependency))] (in outcome)) (#try.Failure error) (do ! - [_ (..announce_failure console repository (get@ #//.artifact dependency))] + [_ (..announce_failure console repository (value@ #//.artifact dependency))] (any console alternatives dependency)))))) (def: .public (all console repositories new_repository dependencies resolution) @@ -213,7 +215,7 @@ [successes failures resolution]) (#.Item head tail) - (case (get@ [#//.artifact #///artifact.version] head) + (case (value@ [#//.artifact #///artifact.version] head) ... Skip if there is no version "" (recur repositories successes diff --git a/stdlib/source/program/aedifex/format.lux b/stdlib/source/program/aedifex/format.lux index 82b15f84d..74583c8f5 100644 --- a/stdlib/source/program/aedifex/format.lux +++ b/stdlib/source/program/aedifex/format.lux @@ -108,13 +108,13 @@ (def: (info value) (Format /.Info) (|> ..empty - (..on_maybe "url" (get@ #/.url value) code.text) - (..on_maybe "scm" (get@ #/.scm value) code.text) - (..on_maybe "description" (get@ #/.description value) code.text) - (..on_list "licenses" (get@ #/.licenses value) ..license) - (..on_maybe "organization" (get@ #/.organization value) ..organization) - (..on_list "developers" (get@ #/.developers value) ..developer) - (..on_list "contributors" (get@ #/.contributors value) ..contributor) + (..on_maybe "url" (value@ #/.url value) code.text) + (..on_maybe "scm" (value@ #/.scm value) code.text) + (..on_maybe "description" (value@ #/.description value) code.text) + (..on_list "licenses" (value@ #/.licenses value) ..license) + (..on_maybe "organization" (value@ #/.organization value) ..organization) + (..on_list "developers" (value@ #/.developers value) ..developer) + (..on_list "contributors" (value@ #/.contributors value) ..contributor) ..aggregate)) (def: (artifact' [group name version]) @@ -142,19 +142,19 @@ (def: .public (profile value) (Format /.Profile) (`` (|> ..empty - (..on_list "parents" (get@ #/.parents value) code.text) - (..on_maybe "identity" (get@ #/.identity value) ..artifact) - (..on_maybe "info" (get@ #/.info value) ..info) - (..on_set "repositories" (get@ #/.repositories value) code.text) - (..on_set "dependencies" (get@ #/.dependencies value) ..dependency) - (dictionary.has "compiler" (..dependency (get@ #/.compiler value))) - (..on_set "sources" (get@ #/.sources value) code.text) - (dictionary.has "target" (code.text (get@ #/.target value))) - (..on_maybe "program" (get@ #/.program value) code.text) - (..on_maybe "test" (get@ #/.test value) code.text) - (..on_dictionary "deploy_repositories" (get@ #/.deploy_repositories value) code.text code.text) + (..on_list "parents" (value@ #/.parents value) code.text) + (..on_maybe "identity" (value@ #/.identity value) ..artifact) + (..on_maybe "info" (value@ #/.info value) ..info) + (..on_set "repositories" (value@ #/.repositories value) code.text) + (..on_set "dependencies" (value@ #/.dependencies value) ..dependency) + (dictionary.has "compiler" (..dependency (value@ #/.compiler value))) + (..on_set "sources" (value@ #/.sources value) code.text) + (dictionary.has "target" (code.text (value@ #/.target value))) + (..on_maybe "program" (value@ #/.program value) code.text) + (..on_maybe "test" (value@ #/.test value) code.text) + (..on_dictionary "deploy_repositories" (value@ #/.deploy_repositories value) code.text code.text) (~~ (template [<tag>] - [(dictionary.has (template.text [<tag>]) (..runtime (get@ <tag> value)))] + [(dictionary.has (template.text [<tag>]) (..runtime (value@ <tag> value)))] [#/.java] [#/.js] diff --git a/stdlib/source/program/aedifex/hash.lux b/stdlib/source/program/aedifex/hash.lux index 63394c8c9..92414c441 100644 --- a/stdlib/source/program/aedifex/hash.lux +++ b/stdlib/source/program/aedifex/hash.lux @@ -31,10 +31,12 @@ (#static getInstance [java/lang/String] java/security/MessageDigest) (digest [[byte]] [byte])]) -(abstract: .public SHA-1 Any) -(abstract: .public MD5 Any) +(abstract: .public SHA-1 {} Any) +(abstract: .public MD5 {} Any) (abstract: .public (Hash h) + {} + Binary (def: .public data @@ -54,13 +56,13 @@ (def: encode (Format Binary) - (binary.fold (function (_ byte representation) - (let [hex (\ n.hex encode byte) - hex (case (text.size hex) - 1 (format "0" hex) - _ hex)] - (format representation hex))) - "")) + (binary.aggregate (function (_ byte representation) + (let [hex (\ n.hex encode byte) + hex (case (text.size hex) + 1 (format "0" hex) + _ hex)] + (format representation hex))) + "")) (template [<factor> <name>] [(def: <name> @@ -128,7 +130,7 @@ (do try.monad [head (\ n.hex decode head) output (binary.write/64! index head output)] - (recur tail (inc chunk) output)) + (recur tail (++ chunk) output)) #.None (case (..hash_size input) diff --git a/stdlib/source/program/aedifex/metadata.lux b/stdlib/source/program/aedifex/metadata.lux index 5badc4783..c8bad9fed 100644 --- a/stdlib/source/program/aedifex/metadata.lux +++ b/stdlib/source/program/aedifex/metadata.lux @@ -18,16 +18,16 @@ (def: .public (remote_artifact_uri artifact) (-> Artifact URI) (let [/ uri.separator] - (format (//artifact.directory / (get@ #//artifact.group artifact)) - / (get@ #//artifact.name artifact) - / (get@ #//artifact.version artifact) + (format (//artifact.directory / (value@ #//artifact.group artifact)) + / (value@ #//artifact.name artifact) + / (value@ #//artifact.version artifact) / ..remote_file))) (def: .public (remote_project_uri artifact) (-> Artifact URI) (let [/ uri.separator] - (format (//artifact.directory / (get@ #//artifact.group artifact)) - / (get@ #//artifact.name artifact) + (format (//artifact.directory / (value@ #//artifact.group artifact)) + / (value@ #//artifact.name artifact) / ..remote_file))) (def: local_file diff --git a/stdlib/source/program/aedifex/metadata/artifact.lux b/stdlib/source/program/aedifex/metadata/artifact.lux index 0d6f86c2c..3512114be 100644 --- a/stdlib/source/program/aedifex/metadata/artifact.lux +++ b/stdlib/source/program/aedifex/metadata/artifact.lux @@ -99,12 +99,12 @@ (-> Metadata XML) (#xml.Node ..<metadata> xml.attributes - (list (..group_format (get@ #group value)) - (..name_format (get@ #name value)) + (list (..group_format (value@ #group value)) + (..name_format (value@ #name value)) (#xml.Node ..<versioning> xml.attributes - (list (..versions_format (get@ #versions value)) - (..last_updated_format (get@ #last_updated value))))))) + (list (..versions_format (value@ #versions value)) + (..last_updated_format (value@ #last_updated value))))))) (def: (text tag) (-> xml.Tag (Parser Text)) diff --git a/stdlib/source/program/aedifex/metadata/snapshot.lux b/stdlib/source/program/aedifex/metadata/snapshot.lux index 90fa9bb86..6a32effef 100644 --- a/stdlib/source/program/aedifex/metadata/snapshot.lux +++ b/stdlib/source/program/aedifex/metadata/snapshot.lux @@ -95,14 +95,14 @@ #///artifact/snapshot/version.updated ///artifact/time.epoch}] (|> (<xml>.somewhere ///artifact/versioning.parser) (\ ! map - (update@ #///artifact/versioning.versions - (: (-> (List ///artifact/snapshot/version.Version) - (List ///artifact/snapshot/version.Version)) - (|>> (case> (^ (list)) - (list <default_version>) + (revised@ #///artifact/versioning.versions + (: (-> (List ///artifact/snapshot/version.Version) + (List ///artifact/snapshot/version.Version)) + (|>> (case> (^ (list)) + (list <default_version>) - versions - versions))))) + versions + versions))))) (<>.else {#///artifact/versioning.snapshot #///artifact/snapshot.Local #///artifact/versioning.last_updated ///artifact/time.epoch #///artifact/versioning.versions (list <default_version>)})))] diff --git a/stdlib/source/program/aedifex/package.lux b/stdlib/source/program/aedifex/package.lux index 6b65a936d..c0c73e0fd 100644 --- a/stdlib/source/program/aedifex/package.lux +++ b/stdlib/source/program/aedifex/package.lux @@ -1,6 +1,6 @@ (.module: [library - [lux #* + [lux (#- local) [abstract [equivalence (#+ Equivalence)]] [control @@ -36,7 +36,7 @@ (template [<name> <tag>] [(def: .public (<name> package) (-> Package Bit) - (case (get@ #origin package) + (case (value@ #origin package) (<tag> _) true @@ -61,19 +61,19 @@ (def: .public dependencies (-> Package (Try (Set Dependency))) - (|>> (get@ #pom) + (|>> (value@ #pom) product.left list (<xml>.result //pom.parser) - (try\map (get@ #/.dependencies)))) + (try\map (value@ #/.dependencies)))) (def: .public repositories (-> Package (Try (Set Address))) - (|>> (get@ #pom) + (|>> (value@ #pom) product.left list (<xml>.result //pom.parser) - (try\map (get@ #/.repositories)))) + (try\map (value@ #/.repositories)))) (def: .public equivalence (Equivalence Package) diff --git a/stdlib/source/program/aedifex/parser.lux b/stdlib/source/program/aedifex/parser.lux index 6d4d05b92..d5f4d3bb8 100644 --- a/stdlib/source/program/aedifex/parser.lux +++ b/stdlib/source/program/aedifex/parser.lux @@ -262,7 +262,7 @@ (Parser Project) (let [default_profile (: (Parser Project) (\ <>.monad map - (|>> [/.else] (list) (dictionary.of_list text.hash)) + (|>> [/.default] (list) (dictionary.of_list text.hash)) ..profile)) multi_profile (: (Parser Project) (\ <>.monad map diff --git a/stdlib/source/program/aedifex/pom.lux b/stdlib/source/program/aedifex/pom.lux index 36e3ff440..810c30588 100644 --- a/stdlib/source/program/aedifex/pom.lux +++ b/stdlib/source/program/aedifex/pom.lux @@ -58,9 +58,9 @@ (def: (artifact value) (-> Artifact (List XML)) - (list (..property ..group_tag (get@ #//artifact.group value)) - (..property ..artifact_tag (get@ #//artifact.name value)) - (..property ..version_tag (get@ #//artifact.version value)))) + (list (..property ..group_tag (value@ #//artifact.group value)) + (..property ..artifact_tag (value@ #//artifact.name value)) + (..property ..version_tag (value@ #//artifact.version value)))) (def: distribution (-> /.Distribution XML) @@ -85,8 +85,8 @@ (-> Dependency XML) (#_.Node ["" ..dependency_tag] _.attributes - (list\compose (..artifact (get@ #//dependency.artifact value)) - (list (..property "type" (get@ #//dependency.type value)))))) + (list\compose (..artifact (value@ #//dependency.artifact value)) + (list (..property "type" (value@ #//dependency.type value)))))) (def: (group tag) (-> Text (-> (List XML) XML)) @@ -128,27 +128,27 @@ (def: (info value) (-> /.Info (List XML)) ($_ list\compose - (|> value (get@ #/.url) (maybe\map (..property ..url_tag)) maybe.list) - (|> value (get@ #/.description) (maybe\map (..property "description")) maybe.list) - (|> value (get@ #/.licenses) (list\map ..license) (..group "licenses") list) - (|> value (get@ #/.scm) (maybe\map ..scm) maybe.list) - (|> value (get@ #/.organization) (maybe\map ..organization) maybe.list) - (|> value (get@ #/.developers) (list\map ..developer) (..group "developers") list) - (|> value (get@ #/.contributors) (list\map ..contributor) (..group "contributors") list) + (|> value (value@ #/.url) (maybe\map (..property ..url_tag)) maybe.list) + (|> value (value@ #/.description) (maybe\map (..property "description")) maybe.list) + (|> value (value@ #/.licenses) (list\map ..license) (..group "licenses") list) + (|> value (value@ #/.scm) (maybe\map ..scm) maybe.list) + (|> value (value@ #/.organization) (maybe\map ..organization) maybe.list) + (|> value (value@ #/.developers) (list\map ..developer) (..group "developers") list) + (|> value (value@ #/.contributors) (list\map ..contributor) (..group "contributors") list) )) ) (def: .public (write value) (-> /.Profile (Try XML)) - (case (get@ #/.identity value) + (case (value@ #/.identity value) (#.Some identity) (#try.Success (#_.Node ["" ..project_tag] _.attributes ($_ list\compose (list ..version) (..artifact identity) - (|> value (get@ #/.repositories) set.list (list\map ..repository) (..group "repositories") list) - (|> value (get@ #/.dependencies) set.list (list\map ..dependency) (..group ..dependencies_tag) list) + (|> value (value@ #/.repositories) set.list (list\map ..repository) (..group "repositories") list) + (|> value (value@ #/.dependencies) set.list (list\map ..dependency) (..group ..dependencies_tag) list) ))) _ @@ -225,7 +225,7 @@ (<>.else (list))) _ (<>.some <xml>.any)] (in (|> (\ /.monoid identity) - (update@ #/.dependencies (function (_ empty) - (list\fold set.has empty dependencies))) - (update@ #/.repositories (function (_ empty) - (list\fold set.has empty repositories))))))))) + (revised@ #/.dependencies (function (_ empty) + (list\fold set.has empty dependencies))) + (revised@ #/.repositories (function (_ empty) + (list\fold set.has empty repositories))))))))) diff --git a/stdlib/source/program/aedifex/profile.lux b/stdlib/source/program/aedifex/profile.lux index 2ff458967..f4a1f9a0d 100644 --- a/stdlib/source/program/aedifex/profile.lux +++ b/stdlib/source/program/aedifex/profile.lux @@ -230,24 +230,24 @@ (def: (compose override baseline) (template.let [(!runtime <tag> <runtime>) - [(if (runtime\= <runtime> (get@ <tag> override)) - (get@ <tag> baseline) - (get@ <tag> override))]] - {#parents (list\compose (get@ #parents baseline) (get@ #parents override)) - #identity (maybe\compose (get@ #identity override) (get@ #identity baseline)) - #info (maybe\compose (get@ #info override) (get@ #info baseline)) - #repositories (set.union (get@ #repositories baseline) (get@ #repositories override)) - #dependencies (set.union (get@ #dependencies baseline) (get@ #dependencies override)) - #compiler (if (dependency\= ..default_compiler (get@ #compiler override)) - (get@ #compiler baseline) - (get@ #compiler override)) - #sources (set.union (get@ #sources baseline) (get@ #sources override)) - #target (if (text\= ..default_target (get@ #target baseline)) - (get@ #target override) - (get@ #target baseline)) - #program (maybe\compose (get@ #program override) (get@ #program baseline)) - #test (maybe\compose (get@ #test override) (get@ #test baseline)) - #deploy_repositories (dictionary.merged (get@ #deploy_repositories override) (get@ #deploy_repositories baseline)) + [(if (runtime\= <runtime> (value@ <tag> override)) + (value@ <tag> baseline) + (value@ <tag> override))]] + {#parents (list\compose (value@ #parents baseline) (value@ #parents override)) + #identity (maybe\compose (value@ #identity override) (value@ #identity baseline)) + #info (maybe\compose (value@ #info override) (value@ #info baseline)) + #repositories (set.union (value@ #repositories baseline) (value@ #repositories override)) + #dependencies (set.union (value@ #dependencies baseline) (value@ #dependencies override)) + #compiler (if (dependency\= ..default_compiler (value@ #compiler override)) + (value@ #compiler baseline) + (value@ #compiler override)) + #sources (set.union (value@ #sources baseline) (value@ #sources override)) + #target (if (text\= ..default_target (value@ #target baseline)) + (value@ #target override) + (value@ #target baseline)) + #program (maybe\compose (value@ #program override) (value@ #program baseline)) + #test (maybe\compose (value@ #test override) (value@ #test baseline)) + #deploy_repositories (dictionary.merged (value@ #deploy_repositories override) (value@ #deploy_repositories baseline)) #java (!runtime #java runtime.default_java) #js (!runtime #js runtime.default_js) #python (!runtime #python runtime.default_python) diff --git a/stdlib/source/program/aedifex/project.lux b/stdlib/source/program/aedifex/project.lux index 951e82d34..5717221d1 100644 --- a/stdlib/source/program/aedifex/project.lux +++ b/stdlib/source/program/aedifex/project.lux @@ -55,17 +55,17 @@ (case (dictionary.value name project) (#.Some profile) (case (list.example (set.member? lineage) - (get@ #//.parents profile)) + (value@ #//.parents profile)) (#.Some ouroboros) (exception.except ..circular_dependency [ouroboros name]) #.None (do {! try.monad} [parents (monad.map ! (profile' (set.has name lineage) project) - (get@ #//.parents profile))] + (value@ #//.parents profile))] (in (list\fold (function (_ parent child) (\ //.monoid compose child parent)) - (set@ #//.parents (list) profile) + (with@ #//.parents (list) profile) parents)))) #.None diff --git a/stdlib/source/program/aedifex/repository/remote.lux b/stdlib/source/program/aedifex/repository/remote.lux index feaf3201f..11d29716e 100644 --- a/stdlib/source/program/aedifex/repository/remote.lux +++ b/stdlib/source/program/aedifex/repository/remote.lux @@ -68,11 +68,11 @@ http))] (case status (^ (static http/status.ok)) - (\ ! map product.right ((get@ #@http.body message) #.None)) + (\ ! map product.right ((value@ #@http.body message) #.None)) _ (do ! - [_ ((get@ #@http.body message) (#.Some 0))] + [_ ((value@ #@http.body message) (#.Some 0))] (\ io.monad in (exception.except ..download_failure [(format address uri) status])))))) (def: (upload uri content) @@ -88,7 +88,7 @@ ..base_headers))) (#.Some content) http)) - _ ((get@ #@http.body message) (#.Some 0))] + _ ((value@ #@http.body message) (#.Some 0))] (case status (^ (static http/status.created)) (in []) diff --git a/stdlib/source/program/aedifex/runtime.lux b/stdlib/source/program/aedifex/runtime.lux index b239d03ea..f029bed15 100644 --- a/stdlib/source/program/aedifex/runtime.lux +++ b/stdlib/source/program/aedifex/runtime.lux @@ -40,7 +40,7 @@ (def: .public (for runtime path) (-> Runtime file.Path Runtime) - (update@ #parameters - (function (_ parameters) - (list\compose parameters (list path))) - runtime)) + (revised@ #parameters + (function (_ parameters) + (list\compose parameters (list path))) + runtime)) diff --git a/stdlib/source/program/compositor.lux b/stdlib/source/program/compositor.lux index 1a6e7356e..7f0e29903 100644 --- a/stdlib/source/program/compositor.lux +++ b/stdlib/source/program/compositor.lux @@ -136,7 +136,7 @@ ..timed (do (try.with async.monad) [.let [[compilation_sources compilation_host_dependencies compilation_libraries compilation_target compilation_module] compilation] - import (/import.import (get@ #platform.&file_system platform) compilation_libraries) + import (/import.import (value@ #platform.&file_system platform) compilation_libraries) [state archive] (:sharing [<parameters>] (Platform <parameters>) platform @@ -151,9 +151,9 @@ (Async (Try [Archive (directive.State+ <parameters>)])) (:expected (platform.compile import static expander platform compilation [archive state]))) - _ (ioW.freeze (get@ #platform.&file_system platform) static archive) + _ (ioW.freeze (value@ #platform.&file_system platform) static archive) program_context (async\in ($/program.context archive)) - host_dependencies (..load_host_dependencies (get@ #platform.&file_system platform) compilation_host_dependencies) + host_dependencies (..load_host_dependencies (value@ #platform.&file_system platform) compilation_host_dependencies) _ (..package! (for {@.old (file.async file.default) @.jvm (file.async file.default) @.js file.default}) @@ -167,7 +167,7 @@ (#/cli.Export export) (<| (or_crash! "Export failed:") (do (try.with async.monad) - [_ (/export.export (get@ #platform.&file_system platform) + [_ (/export.export (value@ #platform.&file_system platform) export)] (in (debug.log! "Export complete!")))) diff --git a/stdlib/source/program/scriptum.lux b/stdlib/source/program/scriptum.lux index dbe3ea022..5083e0afc 100644 --- a/stdlib/source/program/scriptum.lux +++ b/stdlib/source/program/scriptum.lux @@ -51,7 +51,7 @@ (def: type_var_names (Sequence Text) - (|> 0 (sequence.iterations inc) (sequence\map parameter_type_name))) + (|> 0 (sequence.iterations ++) (sequence\map parameter_type_name))) (template [<name> <partition>] [(def: (<name> id) @@ -86,9 +86,9 @@ (if (n.= 0 level) (list) (|> level - dec + -- (enum.range n.enum 0) - (list\map (|>> (n.+ (inc offset)) parameter_type_name))))) + (list\map (|>> (n.+ (++ offset)) parameter_type_name))))) (def: (prefix_lines prefix lines) (-> Text Text Text) @@ -283,28 +283,28 @@ (def: (add_definition [name [exported? def_type def_annotations def_value]] organization) (-> [Text Definition] Organization Organization) (cond (type\= .Type def_type) - (update@ #types - (: (Mutation (List Value)) - (|>> (#.Item [name def_annotations (:as Type def_value)]))) - organization) + (revised@ #types + (: (Mutation (List Value)) + (|>> (#.Item [name def_annotations (:as Type def_value)]))) + organization) (type\= .Macro def_type) - (update@ #macros - (: (Mutation (List [Text Code])) - (|>> (#.Item [name def_annotations]))) - organization) + (revised@ #macros + (: (Mutation (List [Text Code])) + (|>> (#.Item [name def_annotations]))) + organization) (annotation.implementation? def_annotations) - (update@ #implementations - (: (Mutation (List Value)) - (|>> (#.Item [name def_annotations def_type]))) - organization) + (revised@ #implementations + (: (Mutation (List Value)) + (|>> (#.Item [name def_annotations def_type]))) + organization) ... else - (update@ #values - (: (Mutation (List Value)) - (|>> (#.Item [name def_annotations def_type]))) - organization))) + (revised@ #values + (: (Mutation (List Value)) + (|>> (#.Item [name def_annotations def_type]))) + organization))) (def: name_sort (All [r] (-> [Text r] [Text r] Bit)) @@ -319,17 +319,17 @@ #implementations (list) #values (list)}] (|> (list\fold add_definition init defs) - (update@ #types (list.sorted name_sort)) - (update@ #macros (list.sorted name_sort)) - (update@ #implementations (list.sorted name_sort)) - (update@ #values (list.sorted name_sort))))) + (revised@ #types (list.sorted name_sort)) + (revised@ #macros (list.sorted name_sort)) + (revised@ #implementations (list.sorted name_sort)) + (revised@ #values (list.sorted name_sort))))) (def: (unravel_type_func level type) (-> Nat Type Type) (if (n.> 0 level) (case type (#.UnivQ _env _type) - (unravel_type_func (dec level) _type) + (unravel_type_func (-- level) _type) _ type) @@ -371,7 +371,7 @@ (|> type (unravel_type_func nesting) (when> [(new> recursive_type? [])] [unrecurse_type]) - (pprint_type_definition (dec nesting) [_name type_arguments] (maybe.else (list) tags) module interface? recursive_type?) + (pprint_type_definition (-- nesting) [_name type_arguments] (maybe.else (list) tags) module interface? recursive_type?) (text.all_split_by text.new_line) (list\map (|>> (format " "))) (text.interposed text.new_line)) @@ -421,7 +421,7 @@ (template [<singular> <plural> <header>] [(def: (<singular> module type) (-> Text Type (Markdown Block)) - (md.code (pprint_type (dec 0) "?" module type))) + (md.code (pprint_type (-- 0) "?" module type))) (def: (<plural> module values) (-> Text (List Value) (Markdown Block)) @@ -462,7 +462,7 @@ (do meta.monad [.let [(^slots [#types #macros #implementations #values]) organization annotations (|> module - (get@ #.module_annotations) + (value@ #.module_annotations) (maybe.else (' {})) annotation.documentation) description (case annotations diff --git a/stdlib/source/specification/aedifex/repository.lux b/stdlib/source/specification/aedifex/repository.lux index 9f29b2b4c..6a834a0a8 100644 --- a/stdlib/source/specification/aedifex/repository.lux +++ b/stdlib/source/specification/aedifex/repository.lux @@ -29,11 +29,11 @@ [expected (_binary.random 100)] (in ($_ _.and' (do async.monad - [.let [good_uri (/remote.uri (get@ #//artifact.version valid_artifact) valid_artifact //artifact/extension.lux_library)] + [.let [good_uri (/remote.uri (value@ #//artifact.version valid_artifact) valid_artifact //artifact/extension.lux_library)] good_upload! (\ subject upload good_uri expected) good_download! (\ subject download good_uri) - .let [bad_uri (/remote.uri (get@ #//artifact.version invalid_artifact) invalid_artifact //artifact/extension.lux_library)] + .let [bad_uri (/remote.uri (value@ #//artifact.version invalid_artifact) invalid_artifact //artifact/extension.lux_library)] bad_upload! (\ subject upload bad_uri expected) bad_download! (\ subject download bad_uri)] (_.cover' [/.Repository] diff --git a/stdlib/source/specification/compositor.lux b/stdlib/source/specification/compositor.lux index cf7008b76..70c314997 100644 --- a/stdlib/source/specification/compositor.lux +++ b/stdlib/source/specification/compositor.lux @@ -60,7 +60,7 @@ (case ?state,runner,definer (#try.Success [[directive_bundle directive_state] runner definer]) (..test runner definer - (get@ [#directive.analysis #directive.state] directive_state) + (value@ [#directive.analysis #directive.state] directive_state) expander) (#try.Failure error) diff --git a/stdlib/source/specification/compositor/common.lux b/stdlib/source/specification/compositor/common.lux index 3a7f70731..f663de359 100644 --- a/stdlib/source/specification/compositor/common.lux +++ b/stdlib/source/specification/compositor/common.lux @@ -73,9 +73,9 @@ [?state (platform.initialize target expander analysis_bundle platform generation_bundle directive_bundle program extender)] (in (do try.monad [[directive_bundle directive_state] ?state - .let [generation_state (get@ [#directive.generation - #directive.state] - directive_state)]] + .let [generation_state (value@ [#directive.generation + #directive.state] + directive_state)]] (in [[directive_bundle directive_state] (..runner platform generation_state) (..definer platform generation_state)]))))) diff --git a/stdlib/source/specification/compositor/generation/case.lux b/stdlib/source/specification/compositor/generation/case.lux index 371a89162..8508220ed 100644 --- a/stdlib/source/specification/compositor/generation/case.lux +++ b/stdlib/source/specification/compositor/generation/case.lux @@ -36,7 +36,7 @@ (def: (tail? size idx) (-> Nat Nat Bit) - (n.= (dec size) idx)) + (n.= (-- size) idx)) (def: .public (verify expected) (-> Frac (Try Any) Bit) @@ -70,9 +70,9 @@ [subS subP] case .let [unitS (synthesis.text synthesis.unit) caseS (synthesis.tuple - (list.joined (list (list.repeated idx unitS) - (list subS) - (list.repeated (|> size dec (n.- idx)) unitS)))) + (list.together (list (list.repeated idx unitS) + (list subS) + (list.repeated (|> size -- (n.- idx)) unitS)))) caseP ($_ synthesis.path/seq (if (tail? size idx) (synthesis.member/right idx) diff --git a/stdlib/source/specification/compositor/generation/function.lux b/stdlib/source/specification/compositor/generation/function.lux index c3143b958..8a090094f 100644 --- a/stdlib/source/specification/compositor/generation/function.lux +++ b/stdlib/source/specification/compositor/generation/function.lux @@ -34,7 +34,7 @@ (def: (local arity) (-> Arity (Random Register)) - (|> r.nat (r\map (|>> (n.% arity) inc)))) + (|> r.nat (r\map (|>> (n.% arity) ++)))) (def: function (Random [Arity Register Synthesis]) @@ -53,7 +53,7 @@ [[arity local functionS] ..function partial_arity (|> r.nat (\ ! map (|>> (n.% arity) (n.max 1)))) inputs (r.list arity r.safe_frac) - .let [expectation (maybe.trusted (list.item (dec local) inputs)) + .let [expectation (maybe.trusted (list.item (-- local) inputs)) inputsS (list\map (|>> synthesis.f64) inputs)]] ($_ _.and (_.test "Can read arguments." @@ -77,7 +77,7 @@ (enum.range n.enum 1) (list\map (|>> #reference.Local))) variableS (if (n.<= partial_arity local) - (synthesis.variable/foreign (dec local)) + (synthesis.variable/foreign (-- local)) (synthesis.variable/local (|> local (n.- partial_arity)))) inner_arity (n.- partial_arity arity) innerS (synthesis.function/abstraction diff --git a/stdlib/source/specification/compositor/generation/structure.lux b/stdlib/source/specification/compositor/generation/structure.lux index b1f0e5666..de61ed882 100644 --- a/stdlib/source/specification/compositor/generation/structure.lux +++ b/stdlib/source/specification/compositor/generation/structure.lux @@ -33,11 +33,11 @@ (do {! r.monad} [num_tags (|> r.nat (\ ! map (|>> (n.% 10) (n.max 2)))) tag_in (|> r.nat (\ ! map (n.% num_tags))) - .let [last?_in (|> num_tags dec (n.= tag_in))] + .let [last?_in (|> num_tags -- (n.= tag_in))] value_in r.i64] (_.test (%.name (name_of synthesis.variant)) (|> (synthesis.variant {#analysis.lefts (if last?_in - (dec tag_in) + (-- tag_in) tag_in) #analysis.right? last?_in #analysis.value (synthesis.i64 value_in)}) diff --git a/stdlib/source/specification/lux/world/file.lux b/stdlib/source/specification/lux/world/file.lux index 971e312de..0b5414dea 100644 --- a/stdlib/source/specification/lux/world/file.lux +++ b/stdlib/source/specification/lux/world/file.lux @@ -166,7 +166,7 @@ (|>> (text\= child) not) (|>> (text\= sub_dir) not)) (random.ascii/numeric 2)) - expected_file_size (\ ! map (|>> (n.% 10) inc) random.nat) + expected_file_size (\ ! map (|>> (n.% 10) ++) random.nat) content ($binary.random expected_file_size) appendix ($binary.random expected_file_size) expected_time random.instant]) diff --git a/stdlib/source/test/aedifex/artifact/snapshot/version/value.lux b/stdlib/source/test/aedifex/artifact/snapshot/version/value.lux index ada815059..915d283da 100644 --- a/stdlib/source/test/aedifex/artifact/snapshot/version/value.lux +++ b/stdlib/source/test/aedifex/artifact/snapshot/version/value.lux @@ -47,18 +47,18 @@ (do random.monad [sample random stamp $///stamp.random] - (let [version (get@ #/.version sample) + (let [version (value@ #/.version sample) local! (text\= version - (/.format (set@ #/.snapshot #///.Local sample))) + (/.format (with@ #/.snapshot #///.Local sample))) remote_format (/.format {#/.version (format version /.snapshot) #/.snapshot (#///.Remote stamp)}) remote! - (and (text.starts_with? (format version (///time.format (get@ #///stamp.time stamp))) + (and (text.starts_with? (format version (///time.format (value@ #///stamp.time stamp))) remote_format) - (text.ends_with? (%.nat (get@ #///stamp.build stamp)) + (text.ends_with? (%.nat (value@ #///stamp.build stamp)) remote_format))] (_.cover [/.snapshot /.format] (and local! diff --git a/stdlib/source/test/aedifex/artifact/time/time.lux b/stdlib/source/test/aedifex/artifact/time/time.lux index 4dcdac3cc..1f5e4c6e7 100644 --- a/stdlib/source/test/aedifex/artifact/time/time.lux +++ b/stdlib/source/test/aedifex/artifact/time/time.lux @@ -19,7 +19,7 @@ (def: .public random (Random /.Time) - (random.one (|>> time.clock (set@ #time.milli_second 0) time.time) + (random.one (|>> time.clock (with@ #time.milli_second 0) time.time) random.time)) (def: .public test diff --git a/stdlib/source/test/aedifex/cache.lux b/stdlib/source/test/aedifex/cache.lux index 44641af70..91870d680 100644 --- a/stdlib/source/test/aedifex/cache.lux +++ b/stdlib/source/test/aedifex/cache.lux @@ -57,7 +57,7 @@ (try.maybe (do try.monad [pom (//pom.write profile) - identity (try.of_maybe (get@ #//.identity profile))] + identity (try.of_maybe (value@ #//.identity profile))] (in [identity profile pom])))) @profile.random)) @@ -75,7 +75,7 @@ content ..content] (in [{#//dependency.artifact identity #//dependency.type type} - (set@ #//package.origin (#//repository/origin.Remote "") (//package.local pom content))]))) + (with@ #//package.origin (#//repository/origin.Remote "") (//package.local pom content))]))) (def: resolution (Random Resolution) @@ -88,14 +88,14 @@ (do ! [pom (random.one (function (_ [identity profile pom]) (|> profile - (set@ #//.dependencies (set.empty //dependency.hash)) - (set@ #//.identity (#.Some (get@ #//dependency.artifact dependency))) + (with@ #//.dependencies (set.empty //dependency.hash)) + (with@ #//.identity (#.Some (value@ #//dependency.artifact dependency))) //pom.write try.maybe)) ..profile) content ..content] (in [dependency - (set@ #//package.origin (#//repository/origin.Remote "") (//package.local pom content))])))))] + (with@ #//package.origin (#//repository/origin.Remote "") (//package.local pom content))])))))] (in (dictionary.of_list //dependency.hash (list& [main_dependency main_package] dependencies))))) (def: singular @@ -116,7 +116,7 @@ [_ wrote! actual_package read!] (in (\ //package.equivalence = - (set@ #//package.origin (#//repository/origin.Local "") expected_package) + (with@ #//package.origin (#//repository/origin.Local "") expected_package) actual_package))))))))) (def: plural @@ -138,7 +138,7 @@ actual read!] (in (\ //dependency/resolution.equivalence = (\ dictionary.functor map - (set@ #//package.origin (#//repository/origin.Local "")) + (with@ #//package.origin (#//repository/origin.Local "")) expected) actual))))))))) diff --git a/stdlib/source/test/aedifex/command/auto.lux b/stdlib/source/test/aedifex/command/auto.lux index 41d0f080f..ea62b6daa 100644 --- a/stdlib/source/test/aedifex/command/auto.lux +++ b/stdlib/source/test/aedifex/command/auto.lux @@ -53,7 +53,7 @@ [@runs (function (_ console program fs shell resolution profile) (do {! async.monad} - [[_ actual_runs] (async.future (atom.update! inc @runs))] + [[_ actual_runs] (async.future (atom.update! ++ @runs))] (if (n.= expected_runs actual_runs) (in (#try.Failure end_signal)) (do (try.with !) @@ -77,14 +77,14 @@ .let [empty_profile (: Profile (\ ///.monoid identity)) with_target (: (-> Profile Profile) - (set@ #///.target target)) + (with@ #///.target target)) with_program (: (-> Profile Profile) - (set@ #///.program (#.Some program))) + (with@ #///.program (#.Some program))) profile (|> empty_profile with_program with_target - (set@ #///.sources (set.of_list text.hash (list source))))] + (with@ #///.sources (set.of_list text.hash (list source))))] home (random.ascii/alpha 5) working_directory (random.ascii/alpha 5) @@ -103,7 +103,7 @@ _ (\ watcher poll [])] (do {! async.monad} [no_dangling_process! (|> profile - (set@ #///.compiler compiler) + (with@ #///.compiler compiler) ((/.do! 1 watcher command) ($version.echo "") (program.async (program.mock environment.empty home working_directory)) diff --git a/stdlib/source/test/aedifex/command/build.lux b/stdlib/source/test/aedifex/command/build.lux index 81f331e41..03625f0c1 100644 --- a/stdlib/source/test/aedifex/command/build.lux +++ b/stdlib/source/test/aedifex/command/build.lux @@ -151,9 +151,9 @@ .let [empty_profile (: Profile (\ ///.monoid identity)) with_target (: (-> Profile Profile) - (set@ #///.target target)) + (with@ #///.target target)) with_program (: (-> Profile Profile) - (set@ #///.program (#.Some program))) + (with@ #///.program (#.Some program))) profile (|> empty_profile with_program @@ -185,7 +185,7 @@ [verdict (do ///action.monad [_ (/.do! console (program.async (program.mock environment.empty home working_directory)) fs shell resolution - (set@ #///.compiler compiler profile)) + (with@ #///.compiler compiler profile)) start (\ console read_line []) end (\ console read_line [])] (in (and (text\= /.start start) @@ -207,7 +207,7 @@ [verdict (do ///action.monad [_ (/.do! console (program.async (program.mock environment.empty home working_directory)) fs (shell.async (..bad_shell [])) resolution - (set@ #///.compiler compiler profile)) + (with@ #///.compiler compiler profile)) start (\ console read_line []) end (\ console read_line [])] (in (and (text\= /.start start) diff --git a/stdlib/source/test/aedifex/command/clean.lux b/stdlib/source/test/aedifex/command/clean.lux index fffef3033..30ef6eb6f 100644 --- a/stdlib/source/test/aedifex/command/clean.lux +++ b/stdlib/source/test/aedifex/command/clean.lux @@ -103,7 +103,7 @@ context_exists!/pre (..directory_exists? fs context) target_exists!/pre (..assets_exist? fs target_path direct_files) sub_exists!/pre (..assets_exist? fs sub_path sub_files) - _ (/.do! console fs (set@ #///.target target_path dummy)) + _ (/.do! console fs (with@ #///.target target_path dummy)) context_exists!/post (..directory_exists? fs context) target_exists!/post (..assets_exist? fs target_path direct_files) sub_exists!/post (..assets_exist? fs sub_path sub_files) diff --git a/stdlib/source/test/aedifex/command/deploy.lux b/stdlib/source/test/aedifex/command/deploy.lux index 4d11234bd..1df6a4180 100644 --- a/stdlib/source/test/aedifex/command/deploy.lux +++ b/stdlib/source/test/aedifex/command/deploy.lux @@ -55,7 +55,7 @@ (Async (Try Text))) (do ///action.monad [.let [console ($version.echo "")] - _ ($install.make_sources! fs (get@ #///.sources profile)) + _ ($install.make_sources! fs (value@ #///.sources profile)) _ (/.do! console repository fs artifact profile)] (\ console read_line []))) @@ -66,7 +66,7 @@ [[artifact expected_pom profile] (random.one (function (_ profile) (do maybe.monad - [artifact (get@ #///.identity profile) + [artifact (value@ #///.identity profile) expected_pom (try.maybe (///pom.write profile))] (in [artifact expected_pom profile]))) $profile.random) @@ -81,19 +81,19 @@ [verdict (do {! ///action.monad} [logging (..execute! program repository fs artifact profile) expected_library (|> profile - (get@ #///.sources) + (value@ #///.sources) set.list (export.library fs) (\ ! map (format.result tar.writer))) - actual_pom (\ repository download (///repository/remote.uri (get@ #///artifact.version artifact) artifact ///artifact/extension.pom)) - actual_library (\ repository download (///repository/remote.uri (get@ #///artifact.version artifact) artifact ///artifact/extension.lux_library)) - actual_sha-1 (\ repository download (///repository/remote.uri (get@ #///artifact.version artifact) artifact (format ///artifact/extension.lux_library ///artifact/extension.sha-1))) + actual_pom (\ repository download (///repository/remote.uri (value@ #///artifact.version artifact) artifact ///artifact/extension.pom)) + actual_library (\ repository download (///repository/remote.uri (value@ #///artifact.version artifact) artifact ///artifact/extension.lux_library)) + actual_sha-1 (\ repository download (///repository/remote.uri (value@ #///artifact.version artifact) artifact (format ///artifact/extension.lux_library ///artifact/extension.sha-1))) actual_sha-1 (\ async.monad in (do try.monad [actual_sha-1 (\ utf8.codec decode actual_sha-1)] (\ ///hash.sha-1_codec decode actual_sha-1))) - actual_md5 (\ repository download (///repository/remote.uri (get@ #///artifact.version artifact) artifact (format ///artifact/extension.lux_library ///artifact/extension.md5))) + actual_md5 (\ repository download (///repository/remote.uri (value@ #///artifact.version artifact) artifact (format ///artifact/extension.lux_library ///artifact/extension.md5))) actual_md5 (\ async.monad in (do try.monad [actual_md5 (\ utf8.codec decode actual_md5)] diff --git a/stdlib/source/test/aedifex/command/deps.lux b/stdlib/source/test/aedifex/command/deps.lux index 0c6676488..ec45ba697 100644 --- a/stdlib/source/test/aedifex/command/deps.lux +++ b/stdlib/source/test/aedifex/command/deps.lux @@ -73,25 +73,25 @@ #///dependency.type ///artifact/type.lux_library} dependee_pom (|> (\ ///.monoid identity) - (set@ #///.identity (#.Some dependee_artifact)) + (with@ #///.identity (#.Some dependee_artifact)) ///pom.write try.trusted) depender_pom (|> (\ ///.monoid identity) - (set@ #///.identity (#.Some depender_artifact)) - (set@ #///.dependencies (set.of_list ///dependency.hash (list dependee))) + (with@ #///.identity (#.Some depender_artifact)) + (with@ #///.dependencies (set.of_list ///dependency.hash (list dependee))) ///pom.write try.trusted) dependee_package (|> dependee_package - (set@ #///package.origin (#///repository/origin.Remote "")) - (set@ #///package.pom [dependee_pom - (|> dependee_pom (\ xml.codec encode) (\ utf8.codec encode)) - #///dependency/status.Unverified])) + (with@ #///package.origin (#///repository/origin.Remote "")) + (with@ #///package.pom [dependee_pom + (|> dependee_pom (\ xml.codec encode) (\ utf8.codec encode)) + #///dependency/status.Unverified])) depender_package (|> depender_package - (set@ #///package.origin (#///repository/origin.Remote "")) - (set@ #///package.pom [depender_pom - (|> depender_pom (\ xml.codec encode) (\ utf8.codec encode)) - #///dependency/status.Unverified])) + (with@ #///package.origin (#///repository/origin.Remote "")) + (with@ #///package.pom [depender_pom + (|> depender_pom (\ xml.codec encode) (\ utf8.codec encode)) + #///dependency/status.Unverified])) fs (file.mock (\ file.default separator)) program (program.async (program.mock environment.empty home working_directory))]] @@ -103,7 +103,7 @@ (dictionary.has dependee dependee_package) (///dependency/deployment.all local)) post (|> (\ ///.monoid identity) - (set@ #///.dependencies (set.of_list ///dependency.hash (list dependee depender))) + (with@ #///.dependencies (set.of_list ///dependency.hash (list dependee depender))) (/.do! console local (list (///repository.mock ($///dependency/resolution.single depender_artifact depender_package) [])) diff --git a/stdlib/source/test/aedifex/command/install.lux b/stdlib/source/test/aedifex/command/install.lux index 86fe5ebea..f1c0c2de1 100644 --- a/stdlib/source/test/aedifex/command/install.lux +++ b/stdlib/source/test/aedifex/command/install.lux @@ -56,7 +56,7 @@ (-> (Program Async) (file.System Async) ///.Profile (Async (Try Text))) (do ///action.monad [.let [console ($version.echo "")] - _ (..make_sources! fs (get@ #///.sources sample)) + _ (..make_sources! fs (value@ #///.sources sample)) _ (/.do! console fs (///repository/local.repository program fs) sample)] (\ console read_line []))) @@ -65,7 +65,7 @@ (<| (_.covering /._) (do {! random.monad} [identity $artifact.random - sample (\ ! map (set@ #///.identity (#.Some identity)) + sample (\ ! map (with@ #///.identity (#.Some identity)) $profile.random) home (random.ascii/alpha 5) working_directory (random.ascii/alpha 5) @@ -75,7 +75,7 @@ [.let [fs (file.mock /) program (program.async (program.mock environment.empty home working_directory)) - artifact_path (///local.uri (get@ #///artifact.version identity) identity) + artifact_path (///local.uri (value@ #///artifact.version identity) identity) library_path (format artifact_path ///artifact/extension.lux_library) pom_path (format artifact_path ///artifact/extension.pom)] verdict (do {! ///action.monad} @@ -97,7 +97,7 @@ (in (do {! async.monad} [.let [fs (file.mock /) program (program.async (program.mock environment.empty home working_directory))] - logging (..execute! program fs (set@ #///.identity #.None sample))] + logging (..execute! program fs (with@ #///.identity #.None sample))] (_.cover' [/.failure] (|> logging (try\map (text\= /.failure)) diff --git a/stdlib/source/test/aedifex/command/pom.lux b/stdlib/source/test/aedifex/command/pom.lux index 9577842c1..b06a7c944 100644 --- a/stdlib/source/test/aedifex/command/pom.lux +++ b/stdlib/source/test/aedifex/command/pom.lux @@ -62,7 +62,7 @@ (#try.Failure error) (_.cover' [/.do!] - (case (get@ #///.identity sample) + (case (value@ #///.identity sample) (#.Some _) false diff --git a/stdlib/source/test/aedifex/command/test.lux b/stdlib/source/test/aedifex/command/test.lux index f2117fad4..3e3cf85d7 100644 --- a/stdlib/source/test/aedifex/command/test.lux +++ b/stdlib/source/test/aedifex/command/test.lux @@ -50,9 +50,9 @@ .let [empty_profile (: Profile (\ ///.monoid identity)) with_target (: (-> Profile Profile) - (set@ #///.target target)) + (with@ #///.target target)) with_test (: (-> Profile Profile) - (set@ #///.test (#.Some test))) + (with@ #///.test (#.Some test))) profile (|> empty_profile with_test @@ -65,7 +65,7 @@ [verdict (do ///action.monad [_ (/.do! console (program.async (program.mock environment.empty home working_directory)) fs (shell.async (@build.good_shell [])) resolution - (set@ #///.compiler compiler profile)) + (with@ #///.compiler compiler profile)) build_start (\ console read_line []) build_end (\ console read_line []) test_start (\ console read_line []) @@ -101,7 +101,7 @@ [])] _ (/.do! console (program.async (program.mock environment.empty home working_directory)) fs (shell.async bad_shell) resolution - (set@ #///.compiler compiler profile)) + (with@ #///.compiler compiler profile)) build_start (\ console read_line []) build_end (\ console read_line []) test_start (\ console read_line []) diff --git a/stdlib/source/test/aedifex/dependency/deployment.lux b/stdlib/source/test/aedifex/dependency/deployment.lux index ae97a70ca..009298783 100644 --- a/stdlib/source/test/aedifex/dependency/deployment.lux +++ b/stdlib/source/test/aedifex/dependency/deployment.lux @@ -79,20 +79,20 @@ (-> Nat URL Package (Dictionary URL Binary) Artifact Artifact Bit) (let [url (: (-> URI URL) (|>> (format address))) - library_url (url (format (artifact.uri (get@ #artifact.version expected_artifact) + library_url (url (format (artifact.uri (value@ #artifact.version expected_artifact) expected_artifact) artifact/extension.lux_library)) - pom_url (url (format (artifact.uri (get@ #artifact.version expected_artifact) + pom_url (url (format (artifact.uri (value@ #artifact.version expected_artifact) expected_artifact) artifact/extension.pom)) artifact_metadata_url (url (metadata.remote_artifact_uri expected_artifact)) project_metadata_url (url (metadata.remote_project_uri expected_artifact)) expected_library (|> package - (get@ #package.library) + (value@ #package.library) product.left) expected_pom (|> package - (get@ #package.pom) + (value@ #package.pom) product.right product.left) @@ -136,7 +136,7 @@ (do random.monad [[profile package] $///package.random .let [artifact (|> profile - (get@ #profile.identity) + (value@ #profile.identity) maybe.trusted) dependency (: Dependency [artifact diff --git a/stdlib/source/test/aedifex/dependency/resolution.lux b/stdlib/source/test/aedifex/dependency/resolution.lux index c7f7d6d40..44420243d 100644 --- a/stdlib/source/test/aedifex/dependency/resolution.lux +++ b/stdlib/source/test/aedifex/dependency/resolution.lux @@ -98,7 +98,7 @@ (def: .public (single artifact package) (-> Artifact Package (Mock Any)) - (let [expected (///artifact.uri (get@ #///artifact.version artifact) artifact)] + (let [expected (///artifact.uri (value@ #///artifact.version artifact) artifact)] (implementation (def: the_description "[1]") @@ -106,11 +106,11 @@ (if (text.contains? expected uri) (let [library (: Binary (|> package - (get@ #///package.library) + (value@ #///package.library) product.left)) pom (: Binary (|> package - (get@ #///package.pom) + (value@ #///package.pom) product.left (\ xml.codec encode) (\ utf8.codec encode)))] @@ -144,34 +144,34 @@ (def: the_description "[~SHA-1]") (def: (on_download uri state) - (if (text.contains? (///artifact.uri (get@ #///artifact.version expected_artifact) expected_artifact) uri) + (if (text.contains? (///artifact.uri (value@ #///artifact.version expected_artifact) expected_artifact) uri) (cond (text.ends_with? ///artifact/extension.lux_library uri) (#try.Success [state (|> expected_package - (get@ #///package.library) + (value@ #///package.library) product.left)]) (text.ends_with? ..lux_sha-1 uri) (#try.Success [state (|> expected_package - (get@ #///package.library) + (value@ #///package.library) product.left ..sha-1)]) (text.ends_with? ..lux_md5 uri) (#try.Success [state (|> expected_package - (get@ #///package.library) + (value@ #///package.library) product.left ..md5)]) (text.ends_with? ///artifact/extension.pom uri) (#try.Success [state (|> expected_package - (get@ #///package.pom) + (value@ #///package.pom) product.left (\ xml.codec encode) (\ utf8.codec encode))]) (text.ends_with? ..pom_sha-1 uri) (#try.Success [state (|> dummy_package - (get@ #///package.pom) + (value@ #///package.pom) product.left (\ xml.codec encode) (\ utf8.codec encode) @@ -179,7 +179,7 @@ (text.ends_with? ..pom_md5 uri) (#try.Success [state (|> expected_package - (get@ #///package.pom) + (value@ #///package.pom) product.left (\ xml.codec encode) (\ utf8.codec encode) @@ -197,34 +197,34 @@ (def: the_description "[~MD5]") (def: (on_download uri state) - (if (text.contains? (///artifact.uri (get@ #///artifact.version expected_artifact) expected_artifact) uri) + (if (text.contains? (///artifact.uri (value@ #///artifact.version expected_artifact) expected_artifact) uri) (cond (text.ends_with? ///artifact/extension.lux_library uri) (#try.Success [state (|> expected_package - (get@ #///package.library) + (value@ #///package.library) product.left)]) (text.ends_with? ..lux_sha-1 uri) (#try.Success [state (|> expected_package - (get@ #///package.library) + (value@ #///package.library) product.left ..sha-1)]) (text.ends_with? ..lux_md5 uri) (#try.Success [state (|> dummy_package - (get@ #///package.library) + (value@ #///package.library) product.left ..md5)]) (text.ends_with? ///artifact/extension.pom uri) (#try.Success [state (|> expected_package - (get@ #///package.pom) + (value@ #///package.pom) product.left (\ xml.codec encode) (\ utf8.codec encode))]) (text.ends_with? ..pom_sha-1 uri) (#try.Success [state (|> expected_package - (get@ #///package.pom) + (value@ #///package.pom) product.left (\ xml.codec encode) (\ utf8.codec encode) @@ -232,7 +232,7 @@ (text.ends_with? ..pom_md5 uri) (#try.Success [state (|> dummy_package - (get@ #///package.pom) + (value@ #///package.pom) product.left (\ xml.codec encode) (\ utf8.codec encode) @@ -250,7 +250,7 @@ [expected_artifact $///artifact.random [_ expected_package] $///package.random [_ dummy_package] (random.only (|>> product.right - (set@ #///package.pom (get@ #///package.pom expected_package)) + (with@ #///package.pom (value@ #///package.pom expected_package)) (\ ///package.equivalence = expected_package) not) $///package.random) @@ -266,7 +266,7 @@ (case actual_package (#try.Success actual_package) (\ ///package.equivalence = - (set@ #///package.origin (#///repository/origin.Remote "") expected_package) + (with@ #///package.origin (#///repository/origin.Remote "") expected_package) actual_package) (#try.Failure _) @@ -295,7 +295,7 @@ [expected_artifact $///artifact.random [_ expected_package] $///package.random [_ dummy_package] (random.only (|>> product.right - (set@ #///package.pom (get@ #///package.pom expected_package)) + (with@ #///package.pom (value@ #///package.pom expected_package)) (\ ///package.equivalence = expected_package) not) $///package.random) @@ -315,7 +315,7 @@ (case actual_package (#try.Success actual_package) (\ ///package.equivalence = - (set@ #///package.origin (#///repository/origin.Remote "") expected_package) + (with@ #///package.origin (#///repository/origin.Remote "") expected_package) actual_package) (#try.Failure _) @@ -344,8 +344,8 @@ (\ ///artifact.equivalence = dependee_artifact)) $///artifact.random) ignored_artifact (random.only (predicate.complement - (predicate.unite (\ ///artifact.equivalence = dependee_artifact) - (\ ///artifact.equivalence = depender_artifact))) + (predicate.and (\ ///artifact.equivalence = dependee_artifact) + (\ ///artifact.equivalence = depender_artifact))) $///artifact.random)] (in [dependee_artifact depender_artifact ignored_artifact]))) @@ -366,34 +366,34 @@ #///dependency.type ///artifact/type.lux_library} dependee_pom (|> (\ ///.monoid identity) - (set@ #///.identity (#.Some dependee_artifact)) + (with@ #///.identity (#.Some dependee_artifact)) ///pom.write try.trusted) depender_pom (|> (\ ///.monoid identity) - (set@ #///.identity (#.Some depender_artifact)) - (set@ #///.dependencies (set.of_list ///dependency.hash (list dependee))) + (with@ #///.identity (#.Some depender_artifact)) + (with@ #///.dependencies (set.of_list ///dependency.hash (list dependee))) ///pom.write try.trusted) ignored_pom (|> (\ ///.monoid identity) - (set@ #///.identity (#.Some ignored_artifact)) + (with@ #///.identity (#.Some ignored_artifact)) ///pom.write try.trusted) - dependee_package (set@ #///package.pom - [dependee_pom - (|> dependee_pom (\ xml.codec encode) (\ utf8.codec encode)) + dependee_package (with@ #///package.pom + [dependee_pom + (|> dependee_pom (\ xml.codec encode) (\ utf8.codec encode)) + #///dependency/status.Unverified] + dependee_package) + depender_package (with@ #///package.pom + [depender_pom + (|> depender_pom (\ xml.codec encode) (\ utf8.codec encode)) + #///dependency/status.Unverified] + depender_package) + ignored_package (with@ #///package.pom + [ignored_pom + (|> ignored_pom (\ xml.codec encode) (\ utf8.codec encode)) #///dependency/status.Unverified] - dependee_package) - depender_package (set@ #///package.pom - [depender_pom - (|> depender_pom (\ xml.codec encode) (\ utf8.codec encode)) - #///dependency/status.Unverified] - depender_package) - ignored_package (set@ #///package.pom - [ignored_pom - (|> ignored_pom (\ xml.codec encode) (\ utf8.codec encode)) - #///dependency/status.Unverified] - ignored_package)]] + ignored_package)]] (in [[dependee depender ignored] [dependee_package depender_package ignored_package]]))) diff --git a/stdlib/source/test/aedifex/input.lux b/stdlib/source/test/aedifex/input.lux index 086551be0..1c47fdd6f 100644 --- a/stdlib/source/test/aedifex/input.lux +++ b/stdlib/source/test/aedifex/input.lux @@ -45,7 +45,7 @@ Test (<| (_.covering /._) (do {! random.monad} - [expected (\ ! map (set@ #//.parents (list)) $profile.random) + [expected (\ ! map (with@ #//.parents (list)) $profile.random) .let [fs (: (file.System Async) (file.mock (\ file.default separator)))]] (in (do async.monad @@ -59,8 +59,8 @@ (/.read async.monad fs //.default))] (in (\ //.equivalence = (|> expected - (update@ #//.sources ..with_default_source) - (update@ #//.repositories ..with_default_repository)) + (revised@ #//.sources ..with_default_source) + (revised@ #//.repositories ..with_default_repository)) actual)))] (_.cover' [/.read] (try.else false verdict))))))) diff --git a/stdlib/source/test/aedifex/local.lux b/stdlib/source/test/aedifex/local.lux index a797f2a97..a8c0702bb 100644 --- a/stdlib/source/test/aedifex/local.lux +++ b/stdlib/source/test/aedifex/local.lux @@ -23,5 +23,5 @@ ($_ _.and (_.cover [/.repository /.uri] (text.starts_with? /.repository - (/.uri (get@ #//artifact.version sample) sample))) + (/.uri (value@ #//artifact.version sample) sample))) )))) diff --git a/stdlib/source/test/aedifex/metadata/artifact.lux b/stdlib/source/test/aedifex/metadata/artifact.lux index 46ebf4eae..85aafa550 100644 --- a/stdlib/source/test/aedifex/metadata/artifact.lux +++ b/stdlib/source/test/aedifex/metadata/artifact.lux @@ -72,10 +72,10 @@ (_.for [/.Metadata]) (do random.monad [expected ..random - .let [artifact {#///artifact.group (get@ #/.group expected) - #///artifact.name (get@ #/.name expected) + .let [artifact {#///artifact.group (value@ #/.group expected) + #///artifact.name (value@ #/.name expected) #///artifact.version (|> expected - (get@ #/.versions) + (value@ #/.versions) list.head (maybe.else ""))}]] ($_ _.and diff --git a/stdlib/source/test/aedifex/metadata/snapshot.lux b/stdlib/source/test/aedifex/metadata/snapshot.lux index d5dc8595e..2c74296e0 100644 --- a/stdlib/source/test/aedifex/metadata/snapshot.lux +++ b/stdlib/source/test/aedifex/metadata/snapshot.lux @@ -91,7 +91,7 @@ (_.for [/.Metadata]) (do random.monad [expected ..random - .let [artifact (get@ #/.artifact expected)]] + .let [artifact (value@ #/.artifact expected)]] ($_ _.and (_.for [/.equivalence] ($equivalence.spec /.equivalence ..random)) diff --git a/stdlib/source/test/aedifex/package.lux b/stdlib/source/test/aedifex/package.lux index e05c1d753..9596eb63f 100644 --- a/stdlib/source/test/aedifex/package.lux +++ b/stdlib/source/test/aedifex/package.lux @@ -64,18 +64,18 @@ ($equivalence.spec /.equivalence (\ ! map product.right ..random))) (_.cover [/.local?] - (/.local? (set@ #/.origin (#//origin.Local "~/yolo") package))) + (/.local? (with@ #/.origin (#//origin.Local "~/yolo") package))) (_.cover [/.remote?] - (/.remote? (set@ #/.origin (#//origin.Remote "https://example.com") package))) + (/.remote? (with@ #/.origin (#//origin.Remote "https://example.com") package))) (_.cover [/.local] - (let [expected_pom (|> package (get@ #/.pom) product.left) - expected_library (|> package (get@ #/.library) product.left) + (let [expected_pom (|> package (value@ #/.pom) product.left) + expected_library (|> package (value@ #/.library) product.left) local (/.local expected_pom expected_library) - [actual_pom binary_pom pom_status] (get@ #/.pom local) - [actual_library library_status] (get@ #/.library local)] - (and (case (get@ #/.origin local) + [actual_pom binary_pom pom_status] (value@ #/.pom local) + [actual_library library_status] (value@ #/.library local)] + (and (case (value@ #/.origin local) (#//origin.Local "") true _ false) (let [expected_sha1 (//hash.sha-1 expected_library) @@ -104,7 +104,7 @@ _ false)))))) (_.cover [/.dependencies] - (let [expected (get@ #//.dependencies profile)] + (let [expected (value@ #//.dependencies profile)] (case (/.dependencies package) (#try.Success actual) (\ set.equivalence = expected actual) @@ -112,7 +112,7 @@ (#try.Failure error) false))) (_.cover [/.repositories] - (let [expected (get@ #//.repositories profile)] + (let [expected (value@ #//.repositories profile)] (case (/.repositories package) (#try.Success actual) (\ set.equivalence = expected actual) diff --git a/stdlib/source/test/aedifex/parser.lux b/stdlib/source/test/aedifex/parser.lux index 152123d55..6f1516258 100644 --- a/stdlib/source/test/aedifex/parser.lux +++ b/stdlib/source/test/aedifex/parser.lux @@ -55,16 +55,16 @@ (def: with_default_sources (-> //.Profile //.Profile) - (update@ #//.sources - (: (-> (Set //.Source) (Set //.Source)) - (function (_ sources) - (if (set.empty? sources) - (set.of_list text.hash (list //.default_source)) - sources))))) + (revised@ #//.sources + (: (-> (Set //.Source) (Set //.Source)) + (function (_ sources) + (if (set.empty? sources) + (set.of_list text.hash (list //.default_source)) + sources))))) (def: with_default_repository (-> //.Profile //.Profile) - (update@ #//.repositories (set.has //.default_repository))) + (revised@ #//.repositories (set.has //.default_repository))) (def: single_profile Test diff --git a/stdlib/source/test/aedifex/pom.lux b/stdlib/source/test/aedifex/pom.lux index f51ac9abc..e413b69ed 100644 --- a/stdlib/source/test/aedifex/pom.lux +++ b/stdlib/source/test/aedifex/pom.lux @@ -34,15 +34,15 @@ [expected @profile.random] (_.cover [/.write /.parser] (case [(/.write expected) - (get@ #//.identity expected)] + (value@ #//.identity expected)] [(#try.Success pom) (#.Some _)] (case (<xml>.result /.parser (list pom)) (#try.Success actual) (\ //.equivalence = (|> (\ //.monoid identity) - (set@ #//.dependencies (get@ #//.dependencies expected)) - (set@ #//.repositories (get@ #//.repositories expected))) + (with@ #//.dependencies (value@ #//.dependencies expected)) + (with@ #//.repositories (value@ #//.repositories expected))) actual) (#try.Failure error) diff --git a/stdlib/source/test/aedifex/profile.lux b/stdlib/source/test/aedifex/profile.lux index b1ec22e6c..4cb58d0d0 100644 --- a/stdlib/source/test/aedifex/profile.lux +++ b/stdlib/source/test/aedifex/profile.lux @@ -154,10 +154,10 @@ (text\= "" /.default)) (_.cover [/.default_compiler] (|> (\ /.monoid identity) - (get@ #/.compiler) + (value@ #/.compiler) (same? /.default_compiler))) (_.cover [/.default_target] (|> (\ /.monoid identity) - (get@ #/.target) + (value@ #/.target) (same? /.default_target))) ))))) diff --git a/stdlib/source/test/aedifex/project.lux b/stdlib/source/test/aedifex/project.lux index 3d027eec7..291935293 100644 --- a/stdlib/source/test/aedifex/project.lux +++ b/stdlib/source/test/aedifex/project.lux @@ -27,7 +27,7 @@ (def: profile (Random [//.Name //.Profile]) (|> @profile.random - (random\map (set@ #//.parents (list))) + (random\map (with@ #//.parents (list))) (random.and (random.ascii/alpha 1)))) (def: .public random @@ -66,11 +66,11 @@ .let [project ($_ (\ /.monoid compose) (/.project super_name super_profile) (/.project dummy_name dummy_profile) - (/.project sub_name (set@ #//.parents (list super_name) sub_profile))) + (/.project sub_name (with@ #//.parents (list super_name) sub_profile))) circular ($_ (\ /.monoid compose) - (/.project super_name (set@ #//.parents (list sub_name) super_profile)) + (/.project super_name (with@ #//.parents (list sub_name) super_profile)) (/.project dummy_name dummy_profile) - (/.project sub_name (set@ #//.parents (list super_name) sub_profile)))]] + (/.project sub_name (with@ #//.parents (list super_name) sub_profile)))]] ($_ _.and (_.cover [/.profile] (and (|> (/.profile super_name project) diff --git a/stdlib/source/test/aedifex/runtime.lux b/stdlib/source/test/aedifex/runtime.lux index c9e61b017..782b20204 100644 --- a/stdlib/source/test/aedifex/runtime.lux +++ b/stdlib/source/test/aedifex/runtime.lux @@ -44,7 +44,7 @@ (~~ (template [<command>] [(_.cover [/.default_java /.default_js /.default_python /.default_lua /.default_ruby] (let [listing (|> (list /.default_java /.default_js /.default_python /.default_lua /.default_ruby) - (list\map (get@ #/.program))) + (list\map (value@ #/.program))) unique (set.of_list text.hash listing)] (n.= (list.size listing) (set.size unique))))] @@ -57,10 +57,10 @@ )) (_.cover [/.for] (let [runtime' (/.for runtime path)] - (and (text\= (get@ #/.program runtime) - (get@ #/.program runtime')) + (and (text\= (value@ #/.program runtime) + (value@ #/.program runtime')) (|> runtime' - (get@ #/.parameters) + (value@ #/.parameters) list.last (maybe\map (text\= path)) (maybe.else false))))) diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux index a0e00fdd4..6eab1c60b 100644 --- a/stdlib/source/test/lux.lux +++ b/stdlib/source/test/lux.lux @@ -280,20 +280,20 @@ (do random.monad [start random.nat factor random.nat - .let [expected (n.* factor (inc start))]] + .let [expected (n.* factor (++ start))]] ($_ _.and (_.cover [/.|>] (n.= expected - (/.|> start inc (n.* factor)))) + (/.|> start ++ (n.* factor)))) (_.cover [/.|>>] (n.= expected - ((/.|>> inc (n.* factor)) start))) + ((/.|>> ++ (n.* factor)) start))) (_.cover [/.<|] (n.= expected - (/.<| (n.* factor) inc start))) + (/.<| (n.* factor) ++ start))) (_.cover [/.<<|] (n.= expected - ((/.<<| (n.* factor) inc) start))) + ((/.<<| (n.* factor) ++) start))) ))) (def: example_identifier "YOLO") @@ -421,7 +421,7 @@ )) (_.cover [/.Ann] (|> example - (get@ #/.meta) + (value@ #/.meta) (location\= location.dummy))) ))) @@ -432,7 +432,7 @@ "This is an arbitrary text whose only purpose is to be found, somewhere, in the source-code.") (/.macro: (found_crosshair? tokens lux) - (let [[_ _ source_code] (get@ #.source lux)] + (let [[_ _ source_code] (value@ #.source lux)] (#.Right [lux (list (code.bit (text.contains? ..crosshair source_code)))]))) (def: for_macro @@ -572,11 +572,11 @@ (_.cover [/.rev] (same? (: Any expected) (: Any (/.rev expected)))) - (_.cover [/.inc] + (_.cover [/.++] (n.= 1 (n.- expected - (/.inc expected)))) - (_.cover [/.dec] - (n.= 1 (n.- (/.dec expected) + (/.++ expected)))) + (_.cover [/.--] + (n.= 1 (n.- (/.-- expected) expected))) ))) @@ -588,13 +588,13 @@ (_.cover [/.-> /.function] (and (let [actual (: (/.-> Nat Nat Nat) (/.function (_ actual_left actual_right) - (n.* (inc actual_left) (dec actual_right))))] - (n.= (n.* (inc expected_left) (dec expected_right)) + (n.* (++ actual_left) (-- actual_right))))] + (n.= (n.* (++ expected_left) (-- expected_right)) (actual expected_left expected_right))) (let [actual (: (/.-> [Nat Nat] Nat) (/.function (_ [actual_left actual_right]) - (n.* (inc actual_left) (dec actual_right))))] - (n.= (n.* (inc expected_left) (dec expected_right)) + (n.* (++ actual_left) (-- actual_right))))] + (n.= (n.* (++ expected_left) (-- expected_right)) (actual [expected_left expected_right]))))))) (/.template: (!n/+ <left> <right>) @@ -673,72 +673,72 @@ #big_right {#small_left start/s #small_right text}}]] ($_ _.and - (_.cover [/.get@] + (_.cover [/.value@] (and (and (|> sample - (/.get@ #big_left) + (/.value@ #big_left) (same? start/b)) (|> sample - ((/.get@ #big_left)) + ((/.value@ #big_left)) (same? start/b))) (and (|> sample - (/.get@ [#big_right #small_left]) + (/.value@ [#big_right #small_left]) (same? start/s)) (|> sample - ((/.get@ [#big_right #small_left])) + ((/.value@ [#big_right #small_left])) (same? start/s))))) - (_.cover [/.set@] + (_.cover [/.with@] (and (and (|> sample - (/.set@ #big_left shift/b) - (/.get@ #big_left) + (/.with@ #big_left shift/b) + (/.value@ #big_left) (same? shift/b)) (|> sample - ((/.set@ #big_left shift/b)) - (/.get@ #big_left) + ((/.with@ #big_left shift/b)) + (/.value@ #big_left) (same? shift/b)) (|> sample - ((/.set@ #big_left) shift/b) - (/.get@ #big_left) + ((/.with@ #big_left) shift/b) + (/.value@ #big_left) (same? shift/b))) (and (|> sample - (/.set@ [#big_right #small_left] shift/s) - (/.get@ [#big_right #small_left]) + (/.with@ [#big_right #small_left] shift/s) + (/.value@ [#big_right #small_left]) (same? shift/s)) (|> sample - ((/.set@ [#big_right #small_left] shift/s)) - (/.get@ [#big_right #small_left]) + ((/.with@ [#big_right #small_left] shift/s)) + (/.value@ [#big_right #small_left]) (same? shift/s)) (|> sample - ((/.set@ [#big_right #small_left]) shift/s) - (/.get@ [#big_right #small_left]) + ((/.with@ [#big_right #small_left]) shift/s) + (/.value@ [#big_right #small_left]) (same? shift/s))))) - (_.cover [/.update@] + (_.cover [/.revised@] (and (and (|> sample - (/.update@ #big_left (n.+ shift/b)) - (/.get@ #big_left) + (/.revised@ #big_left (n.+ shift/b)) + (/.value@ #big_left) (n.= expected/b)) (|> sample - ((/.update@ #big_left (n.+ shift/b))) - (/.get@ #big_left) + ((/.revised@ #big_left (n.+ shift/b))) + (/.value@ #big_left) (n.= expected/b)) (|> sample ((: (-> (-> Nat Nat) (-> Big Big)) - (/.update@ #big_left)) + (/.revised@ #big_left)) (n.+ shift/b)) - (/.get@ #big_left) + (/.value@ #big_left) (n.= expected/b))) (and (|> sample - (/.update@ [#big_right #small_left] (n.+ shift/s)) - (/.get@ [#big_right #small_left]) + (/.revised@ [#big_right #small_left] (n.+ shift/s)) + (/.value@ [#big_right #small_left]) (n.= expected/s)) (|> sample - ((/.update@ [#big_right #small_left] (n.+ shift/s))) - (/.get@ [#big_right #small_left]) + ((/.revised@ [#big_right #small_left] (n.+ shift/s))) + (/.value@ [#big_right #small_left]) (n.= expected/s)) (|> sample ((: (-> (-> Nat Nat) (-> Big Big)) - (/.update@ [#big_right #small_left])) + (/.revised@ [#big_right #small_left])) (n.+ shift/s)) - (/.get@ [#big_right #small_left]) + (/.value@ [#big_right #small_left]) (n.= expected/s))))) ))) @@ -862,7 +862,7 @@ (hide left)) true))) (_.cover [/.same?] - (let [not_left (|> left inc dec)] + (let [not_left (|> left ++ --)] (and (/.same? left left) (and (n.= not_left left) (not (/.same? not_left left)))))) @@ -1009,7 +1009,7 @@ (/.loop [counter 0 value 0] (if (n.< iterations counter) - (recur (inc counter) (n.+ factor value)) + (recur (++ counter) (n.+ factor value)) value))))) (do random.monad [pre random.nat @@ -1051,13 +1051,13 @@ (syntax: (for_meta|Info []) (function (_ lux) - (let [info (get@ #.info lux) + (let [info (value@ #.info lux) conforming_target! - (set.member? ..possible_targets (get@ #.target info)) + (set.member? ..possible_targets (value@ #.target info)) compiling! - (case (get@ #.mode info) + (case (value@ #.mode info) #.Build true _ false)] (#.Right [lux (list (code.bit (and conforming_target! @@ -1066,7 +1066,7 @@ (syntax: (for_meta|Module_State []) (do meta.monad [prelude_module (meta.module .prelude_module)] - (in (list (code.bit (case (get@ #.module_state prelude_module) + (in (list (code.bit (case (value@ #.module_state prelude_module) #.Active false _ true)))))) @@ -1103,22 +1103,22 @@ let/2 <code>.local_identifier let/3 <code>.local_identifier]) - (in (list (code.bit (case (get@ #.scopes *lux*) + (in (list (code.bit (case (value@ #.scopes *lux*) (^ (list& scope/2 _)) - (let [locals/2 (get@ #.locals scope/2) + (let [locals/2 (value@ #.locals scope/2) expected_locals/2 (set.of_list text.hash (list fn/2 var/2 let/2 let/3)) actual_locals/2 (|> locals/2 - (get@ #.mappings) + (value@ #.mappings) (list\map product.left) (set.of_list text.hash)) correct_locals! - (and (n.= 4 (get@ #.counter locals/2)) + (and (n.= 4 (value@ #.counter locals/2)) (set\= expected_locals/2 actual_locals/2)) - captured/2 (get@ #.captured scope/2) + captured/2 (value@ #.captured scope/2) local? (: (-> Ref Bit) (function (_ ref) @@ -1130,13 +1130,13 @@ binding? (: (-> (-> Ref Bit) Text Bit) (function (_ is? name) (|> captured/2 - (get@ #.mappings) + (value@ #.mappings) (plist.value name) (maybe\map (|>> product.right is?)) (maybe.else false)))) correct_closure! - (and (n.= 6 (get@ #.counter captured/2)) + (and (n.= 6 (value@ #.counter captured/2)) (binding? local? fn/1) (binding? local? var/1) (binding? local? let/1) diff --git a/stdlib/source/test/lux/abstract/comonad.lux b/stdlib/source/test/lux/abstract/comonad.lux index 431272d9f..05067e786 100644 --- a/stdlib/source/test/lux/abstract/comonad.lux +++ b/stdlib/source/test/lux/abstract/comonad.lux @@ -20,9 +20,9 @@ (<| (_.covering /._) ($_ _.and (_.cover [/.be] - (n.= (inc sample) + (n.= (++ sample) (: (Identity Nat) (/.be identity.comonad [value (out sample)] - (out (inc value)))))) + (out (++ value)))))) )))) diff --git a/stdlib/source/test/lux/abstract/enum.lux b/stdlib/source/test/lux/abstract/enum.lux index 88d4cc732..179dad8df 100644 --- a/stdlib/source/test/lux/abstract/enum.lux +++ b/stdlib/source/test/lux/abstract/enum.lux @@ -31,7 +31,7 @@ (<| (_.covering /._) ($_ _.and (_.cover [/.range] - (let [expected_size (|> end (n.- start) inc) + (let [expected_size (|> end (n.- start) ++) expected_start? (|> range list.head (maybe\map (n.= start)) (maybe.else false)) expected_end? (|> range list.last (maybe\map (n.= end)) (maybe.else false)) can_be_backwards? (\ (list.equivalence n.equivalence) = diff --git a/stdlib/source/test/lux/abstract/monad.lux b/stdlib/source/test/lux/abstract/monad.lux index 0fc605a0c..051f63a5c 100644 --- a/stdlib/source/test/lux/abstract/monad.lux +++ b/stdlib/source/test/lux/abstract/monad.lux @@ -21,30 +21,30 @@ (<| (_.covering /._) ($_ _.and (_.cover [/.do] - (n.= (inc mono) + (n.= (++ mono) (: (Identity Nat) (/.do identity.monad [sample (in mono)] - (in (inc sample)))))) - (_.cover [/.bind] - (n.= (inc mono) + (in (++ sample)))))) + (_.cover [/.then] + (n.= (++ mono) (: (Identity Nat) - (/.bind identity.monad - (|>> inc (\ identity.monad in)) + (/.then identity.monad + (|>> ++ (\ identity.monad in)) (\ identity.monad in mono))))) - (_.cover [/.seq] + (_.cover [/.all] (\ (list.equivalence n.equivalence) = - (list\map inc poly) + (list\map ++ poly) (|> poly - (list\map (|>> inc (\ identity.monad in))) + (list\map (|>> ++ (\ identity.monad in))) (: (List (Identity Nat))) - (/.seq identity.monad) + (/.all identity.monad) (: (Identity (List Nat)))))) (_.cover [/.map] (\ (list.equivalence n.equivalence) = - (list\map inc poly) + (list\map ++ poly) (|> poly - (/.map identity.monad (|>> inc (\ identity.monad in))) + (/.map identity.monad (|>> ++ (\ identity.monad in))) (: (Identity (List Nat)))))) (_.cover [/.only] (\ (list.equivalence n.equivalence) = diff --git a/stdlib/source/test/lux/abstract/monad/free.lux b/stdlib/source/test/lux/abstract/monad/free.lux index b583f4a8e..523741df6 100644 --- a/stdlib/source/test/lux/abstract/monad/free.lux +++ b/stdlib/source/test/lux/abstract/monad/free.lux @@ -31,7 +31,7 @@ (#/.Effect effect) (|> effect (list\map interpret) - list.joined))) + list.together))) (def: comparison (Comparison (/.Free List)) diff --git a/stdlib/source/test/lux/control/concatenative.lux b/stdlib/source/test/lux/control/concatenative.lux index deb5601a7..97b7a48f6 100644 --- a/stdlib/source/test/lux/control/concatenative.lux +++ b/stdlib/source/test/lux/control/concatenative.lux @@ -76,18 +76,18 @@ [/.||L #.Left] [/.||R #.Right])) (_.cover [/.dip] - (n.= (inc sample) + (n.= (++ sample) (||> (/.push sample) (/.push dummy) - (/.push (/.apply/1 inc)) + (/.push (/.apply/1 ++)) /.dip /.drop))) (_.cover [/.dip/2] - (n.= (inc sample) + (n.= (++ sample) (||> (/.push sample) (/.push dummy) (/.push dummy) - (/.push (/.apply/1 inc)) + (/.push (/.apply/1 ++)) /.dip/2 /.drop /.drop))) )))) @@ -142,13 +142,13 @@ sample random.nat start random.nat .let [distance 10 - |inc| (/.apply/1 inc) + |++| (/.apply/1 ++) |test| (/.apply/1 (|>> (n.- start) (n.< distance)))]] ($_ _.and (_.cover [/.call /.apply/1] - (n.= (inc sample) + (n.= (++ sample) (||> (/.push sample) - (/.push (/.apply/1 inc)) + (/.push (/.apply/1 ++)) /.call))) (_.cover [/.apply/2] (n.= (n.+ sample sample) @@ -235,35 +235,35 @@ /.call))) (_.cover [/.if] (n.= (if choice - (inc sample) - (dec sample)) + (++ sample) + (-- sample)) (||> (/.push sample) (/.push choice) - (/.push (/.apply/1 inc)) - (/.push (/.apply/1 dec)) + (/.push (/.apply/1 ++)) + (/.push (/.apply/1 --)) /.if))) (_.cover [/.loop] (n.= (n.+ distance start) (||> (/.push start) - (/.push (|>> |inc| /.dup |test|)) + (/.push (|>> |++| /.dup |test|)) /.loop))) (_.cover [/.while] (n.= (n.+ distance start) (||> (/.push start) (/.push (|>> /.dup |test|)) - (/.push |inc|) + (/.push |++|) /.while))) (_.cover [/.do] - (n.= (inc sample) + (n.= (++ sample) (||> (/.push sample) (/.push (|>> (/.push false))) - (/.push |inc|) + (/.push |++|) /.do /.while))) (_.cover [/.compose] - (n.= (inc (inc sample)) + (n.= (++ (++ sample)) (||> (/.push sample) - (/.push |inc|) - (/.push |inc|) + (/.push |++|) + (/.push |++|) /.compose /.call))) (_.cover [/.partial] @@ -275,19 +275,19 @@ /.call))) (_.cover [/.when] (n.= (if choice - (inc sample) + (++ sample) sample) (||> (/.push sample) (/.push choice) - (/.push (/.apply/1 inc)) + (/.push (/.apply/1 ++)) /.when))) (_.cover [/.?] (n.= (if choice - (inc sample) - (dec sample)) + (++ sample) + (-- sample)) (||> (/.push choice) - (/.push (inc sample)) - (/.push (dec sample)) + (/.push (++ sample)) + (/.push (-- sample)) /.?))) ))) diff --git a/stdlib/source/test/lux/control/concurrency/actor.lux b/stdlib/source/test/lux/control/concurrency/actor.lux index 627b294ad..93c68faff 100644 --- a/stdlib/source/test/lux/control/concurrency/actor.lux +++ b/stdlib/source/test/lux/control/concurrency/actor.lux @@ -55,8 +55,8 @@ (function (_ transform) (function (_ state actor) (|> state transform #try.Success async\in)))) - inc! (: (/.Mail Nat) (as_mail inc)) - dec! (: (/.Mail Nat) (as_mail dec))]] + ++! (: (/.Mail Nat) (as_mail ++)) + --! (: (/.Mail Nat) (as_mail --))]] (<| (_.covering /._) (_.for [/.Actor]) ($_ _.and @@ -116,7 +116,7 @@ (in (do async.monad [sent? (async.future (do io.monad [actor (/.spawn! /.default 0) - sent? (/.mail! inc! actor)] + sent? (/.mail! ++! actor)] (in (..mailed? sent?))))] (_.cover' [/.Behavior /.Mail /.default /.spawn! /.mail!] @@ -126,7 +126,7 @@ [result (async.future (do io.monad [counter (/.spawn! /.default 0) _ (/.poison! counter)] - (/.mail! inc! counter)))] + (/.mail! ++! counter)))] (_.cover' [/.dead] (case result (#try.Success outcome) @@ -180,18 +180,18 @@ [anonymous (/.actor {Nat initial_state} ((on_mail message state self) - (message (inc state) self))) - sent/inc? (/.mail! inc! anonymous) - sent/dec? (/.mail! dec! anonymous) + (message (++ state) self))) + sent/++? (/.mail! ++! anonymous) + sent/--? (/.mail! --! anonymous) poisoned? (/.poison! anonymous) obituary (/.obituary' anonymous)] - (in (and (..mailed? sent/inc?) - (..mailed? sent/dec?) + (in (and (..mailed? sent/++?) + (..mailed? sent/--?) (..mailed? poisoned?) (case obituary (^ (#.Some [error final_state (list poison_pill)])) (and (exception.match? /.poisoned error) - (n.= (inc (inc initial_state)) + (n.= (++ (++ initial_state)) final_state)) _ @@ -200,7 +200,7 @@ verdict))) (do ! - [num_events (\ ! map (|>> (n.% 10) inc) random.nat) + [num_events (\ ! map (|>> (n.% 10) ++) random.nat) events (random.list num_events random.nat) num_observations (\ ! map (n.% num_events) random.nat) .let [expected (list.first num_observations events) @@ -215,8 +215,8 @@ (async.future (if (n.< num_observations events_seen) (do ! - [_ (atom.update! (row.add event) sink)] - (in (#try.Success (inc events_seen)))) + [_ (atom.update! (row.suffix event) sink)] + (in (#try.Success (++ events_seen)))) (do ! [_ stop] (in (#try.Failure "YOLO"))))))) diff --git a/stdlib/source/test/lux/control/concurrency/async.lux b/stdlib/source/test/lux/control/concurrency/async.lux index a92a5c44c..f9b917ee5 100644 --- a/stdlib/source/test/lux/control/concurrency/async.lux +++ b/stdlib/source/test/lux/control/concurrency/async.lux @@ -107,16 +107,16 @@ (n.+ leftA rightA))))) (in (do /.monad [pre (/.future instant.now) - actual (/.delayed waiting_time expected) + actual (/.after waiting_time expected) post (/.future instant.now)] - (_.cover' [/.delayed] + (_.cover' [/.after] (and (n.= expected actual) (i.>= (.int waiting_time) (duration.millis (instant.span pre post))))))) (in (do /.monad [?left (/.or (in leftE) - (/.delayed waiting_time dummy)) - ?right (/.or (/.delayed waiting_time dummy) + (/.after waiting_time dummy)) + ?right (/.or (/.after waiting_time dummy) (in rightE))] (_.cover' [/.or] (case [?left ?right] @@ -128,8 +128,8 @@ false)))) (in (do /.monad [leftA (/.either (in leftE) - (/.delayed waiting_time dummy)) - rightA (/.either (/.delayed waiting_time dummy) + (/.after waiting_time dummy)) + rightA (/.either (/.after waiting_time dummy) (in rightE))] (_.cover' [/.either] (n.= (n.+ leftE rightE) @@ -155,9 +155,9 @@ (and yep (not nope))))) (in (do /.monad - [?none (/.time_out 0 (/.delayed waiting_time dummy)) - ?actual (/.time_out waiting_time (in expected))] - (_.cover' [/.time_out] + [?none (/.within 0 (/.after waiting_time dummy)) + ?actual (/.within waiting_time (in expected))] + (_.cover' [/.within] (case [?none ?actual] [#.None (#.Some actual)] (n.= expected actual) diff --git a/stdlib/source/test/lux/control/concurrency/frp.lux b/stdlib/source/test/lux/control/concurrency/frp.lux index 45dadc8cb..5876331b6 100644 --- a/stdlib/source/test/lux/control/concurrency/frp.lux +++ b/stdlib/source/test/lux/control/concurrency/frp.lux @@ -60,7 +60,7 @@ (#.Some [head tail]) (\ ! map (|>> (#.Item head)) - (take_amount (dec amount_of_polls) [channel sink])))))) + (take_amount (-- amount_of_polls) [channel sink])))))) (def: .public test Test @@ -145,9 +145,9 @@ _ (async.future (/.subscribe! (function (_ value) (do {! io.monad} [current (atom.read! sink) - _ (atom.update! (row.add value) sink)] + _ (atom.update! (row.suffix value) sink)] (if (n.< (list.size inputs) - (inc (row.size current))) + (++ (row.size current))) (in (#.Some [])) (do ! [_ (!signal [])] @@ -161,22 +161,22 @@ (_.cover' [/.Subscriber /.subscribe!] (list\= inputs listened)))) (in (do async.monad - [actual (/.fold (function (_ input total) - (async.resolved (n.+ input total))) - 0 - (/.sequential 0 inputs))] - (_.cover' [/.fold] + [actual (/.aggregate (function (_ input total) + (async.resolved (n.+ input total))) + 0 + (/.sequential 0 inputs))] + (_.cover' [/.aggregate] (n.= (list\fold n.+ 0 inputs) actual)))) (in (do async.monad [actual (|> inputs (/.sequential 0) - (/.folds (function (_ input total) - (async.resolved (n.+ input total))) - 0) + (/.aggregates (function (_ input total) + (async.resolved (n.+ input total))) + 0) /.list)] - (_.cover' [/.folds] - (list\= (list.folds n.+ 0 inputs) + (_.cover' [/.aggregates] + (list\= (list.aggregates n.+ 0 inputs) actual)))) (in (do async.monad [actual (|> (list distint/0 distint/0 distint/0 @@ -189,8 +189,8 @@ (list\= (list distint/0 distint/1 distint/2) actual)))) (do ! - [polling_delay (\ ! map (|>> (n.% 10) inc) random.nat) - amount_of_polls (\ ! map (|>> (n.% 10) inc) random.nat)] + [polling_delay (\ ! map (|>> (n.% 10) ++) random.nat) + amount_of_polls (\ ! map (|>> (n.% 10) ++) random.nat)] ($_ _.and (in (do {! async.monad} [actual (..take_amount amount_of_polls (/.poll polling_delay (: (IO Nat) (io.io sample)))) @@ -212,12 +212,12 @@ (/.iterations (function (_ [iterations current]) (async.resolved (if (n.< max_iterations iterations) - (#.Some [[(inc iterations) (n.+ shift current)] + (#.Some [[(++ iterations) (n.+ shift current)] current]) #.None)))) /.list)] (_.cover' [/.iterations] (and (n.= max_iterations (list.size actual)) - (list\= (list.folds n.+ sample (list.repeated (dec max_iterations) shift)) + (list\= (list.aggregates n.+ sample (list.repeated (-- max_iterations) shift)) actual))))) ))))) diff --git a/stdlib/source/test/lux/control/concurrency/semaphore.lux b/stdlib/source/test/lux/control/concurrency/semaphore.lux index a57e3bcd6..b4b07bbb0 100644 --- a/stdlib/source/test/lux/control/concurrency/semaphore.lux +++ b/stdlib/source/test/lux/control/concurrency/semaphore.lux @@ -42,7 +42,7 @@ [initial_open_positions (|> random.nat (\ ! map (|>> (n.% 10) (n.max 1)))) .let [semaphore (/.semaphore initial_open_positions)]] (in (do async.monad - [result (async.time_out ..delay (/.wait! semaphore))] + [result (async.within ..delay (/.wait! semaphore))] (_.cover' [/.semaphore] (case result (#.Some _) @@ -55,7 +55,7 @@ .let [semaphore (/.semaphore initial_open_positions)]] (in (do {! async.monad} [_ (monad.map ! /.wait! (list.repeated initial_open_positions semaphore)) - result (async.time_out ..delay (/.wait! semaphore))] + result (async.within ..delay (/.wait! semaphore))] (_.cover' [/.wait!] (case result (#.Some _) @@ -69,9 +69,9 @@ (in (do {! async.monad} [_ (monad.map ! /.wait! (list.repeated initial_open_positions semaphore)) .let [block (/.wait! semaphore)] - result/0 (async.time_out ..delay block) + result/0 (async.within ..delay block) open_positions (/.signal! semaphore) - result/1 (async.time_out ..delay block)] + result/1 (async.within ..delay block)] (_.cover' [/.signal!] (case [result/0 result/1 open_positions] [#.None (#.Some _) (#try.Success +0)] @@ -100,14 +100,14 @@ (do {! random.monad} [repetitions (|> random.nat (\ ! map (|>> (n.% 100) (n.max 10)))) .let [resource (atom.atom "") - expected_As (text.joined (list.repeated repetitions "A")) - expected_Bs (text.joined (list.repeated repetitions "B")) + expected_As (text.together (list.repeated repetitions "A")) + expected_Bs (text.together (list.repeated repetitions "B")) mutex (/.mutex []) processA (<| (/.synchronize! mutex) io.io async.future (do {! io.monad} - [_ (<| (monad.seq !) + [_ (<| (monad.all !) (list.repeated repetitions) (atom.update! (|>> (format "A")) resource))] (in []))) @@ -115,7 +115,7 @@ io.io async.future (do {! io.monad} - [_ (<| (monad.seq !) + [_ (<| (monad.all !) (list.repeated repetitions) (atom.update! (|>> (format "B")) resource))] (in [])))]] @@ -155,21 +155,21 @@ _ false))) (do {! random.monad} - [limit (\ ! map (|>> (n.% 9) inc) random.nat) + [limit (\ ! map (|>> (n.% 9) ++) random.nat) .let [barrier (/.barrier (maybe.trusted (/.limit limit))) resource (atom.atom "")]] (in (do {! async.monad} [.let [suffix "_" expected_ending (|> suffix (list.repeated limit) - text.joined) - expected_ids (enum.range n.enum 0 (dec limit))] + text.together) + expected_ids (enum.range n.enum 0 (-- limit))] _ (|> expected_ids (list\map (function (_ id) (exec (io.run! (atom.update! (|>> (format suffix)) resource)) (waiter resource barrier id)))) - (monad.seq !)) + (monad.all !)) .let [outcome (io.run! (atom.read! resource))]] (_.cover' [/.barrier /.block!] (and (text.ends_with? expected_ending outcome) diff --git a/stdlib/source/test/lux/control/concurrency/stm.lux b/stdlib/source/test/lux/control/concurrency/stm.lux index dbe98177f..f3a5c618c 100644 --- a/stdlib/source/test/lux/control/concurrency/stm.lux +++ b/stdlib/source/test/lux/control/concurrency/stm.lux @@ -94,8 +94,8 @@ (in (let [var (/.var 0)] (do {! async.monad} [_ (|> (list.repeated iterations_per_process []) - (list\map (function (_ _) (/.commit! (/.update inc var)))) - (monad.seq !)) + (list\map (function (_ _) (/.commit! (/.update ++ var)))) + (monad.all !)) cummulative (/.commit! (/.read var))] (_.cover' [/.STM] (n.= iterations_per_process diff --git a/stdlib/source/test/lux/control/continuation.lux b/stdlib/source/test/lux/control/continuation.lux index 4844e521f..cac3794a0 100644 --- a/stdlib/source/test/lux/control/continuation.lux +++ b/stdlib/source/test/lux/control/continuation.lux @@ -63,7 +63,7 @@ (/.result (do /.monad [[restart [output idx]] (/.portal [sample 0])] (if (n.< 10 idx) - (restart [(n.+ 10 output) (inc idx)]) + (restart [(n.+ 10 output) (++ idx)]) (in output)))))) (_.cover [/.shift /.reset] (let [(^open "_\.") /.monad diff --git a/stdlib/source/test/lux/control/function.lux b/stdlib/source/test/lux/control/function.lux index 369a018e0..4450991ec 100644 --- a/stdlib/source/test/lux/control/function.lux +++ b/stdlib/source/test/lux/control/function.lux @@ -56,9 +56,9 @@ outcome) (not (n.= (n.- expected extra) outcome))))) - (_.cover [/.apply] + (_.cover [/.on] (n.= (f0 extra) - (/.apply extra f0))) + (/.on extra f0))) /contract.test /memo.test diff --git a/stdlib/source/test/lux/control/function/memo.lux b/stdlib/source/test/lux/control/function/memo.lux index a91f2a69a..914247204 100644 --- a/stdlib/source/test/lux/control/function/memo.lux +++ b/stdlib/source/test/lux/control/function/memo.lux @@ -85,7 +85,7 @@ open (/.open fibonacci)] [none_time none_output] (..time none input) [open_time [memory open_output]] (..time open [memory input]) - [open_time/+1 _] (..time open [memory (inc input)]) + [open_time/+1 _] (..time open [memory (++ input)]) .let [same_output! (n.= none_output open_output) @@ -108,10 +108,10 @@ (case input (^or 0 1) (\ state.monad in 1) _ (do state.monad - [output' (recur (dec input))] + [output' (recur (-- input))] (in (n.* input output'))))))) expected (|> (list.indices input) - (list\map inc) + (list\map ++) (list\fold n.* 1)) actual (|> (memo input) (state.result (dictionary.empty n.hash)) diff --git a/stdlib/source/test/lux/control/function/mixin.lux b/stdlib/source/test/lux/control/function/mixin.lux index 19e67b7aa..b41da5623 100644 --- a/stdlib/source/test/lux/control/function/mixin.lux +++ b/stdlib/source/test/lux/control/function/mixin.lux @@ -39,7 +39,7 @@ (in (function (_ delegate recur input) output)))) expected (|> (list.indices input) - (list\map inc) + (list\map ++) (list\fold n.* 1))]]) ($_ _.and (_.for [/.Mixin] @@ -52,7 +52,7 @@ (function (_ delegate recur input) (case input (^or 0 1) 1 - _ (n.* input (recur (dec input))))))] + _ (n.* input (recur (-- input))))))] (n.= expected (factorial input)))) (_.cover [/.with] @@ -63,7 +63,7 @@ _ (delegate input)))) multiplication (: (/.Mixin Nat Nat) (function (_ delegate recur input) - (n.* input (recur (dec input))))) + (n.* input (recur (-- input))))) factorial (/.mixin (/.with bottom multiplication))] (n.= expected (factorial input)))) @@ -72,7 +72,7 @@ (function (_ delegate recur input) (case input (^or 0 1) 1 - _ (n.* input (delegate (dec input)))))) + _ (n.* input (delegate (-- input)))))) left (/.mixin (/.with /.nothing loop)) right (/.mixin (/.with loop /.nothing))] (and (n.= expected @@ -90,7 +90,7 @@ _ false))) multiplication (: (/.Mixin Nat Nat) (function (_ delegate recur input) - (n.* input (recur (dec input))))) + (n.* input (recur (-- input))))) factorial (/.mixin (/.with (/.advice bottom? bottom) multiplication))] (n.= expected @@ -129,7 +129,7 @@ (function (_ recur input) (case input (^or 0 1) 1 - _ (n.* input (recur (dec input)))))))] + _ (n.* input (recur (-- input)))))))] (n.= expected (factorial input))))) ))) diff --git a/stdlib/source/test/lux/control/function/mutual.lux b/stdlib/source/test/lux/control/function/mutual.lux index 5aeb9be71..4fe2e4219 100644 --- a/stdlib/source/test/lux/control/function/mutual.lux +++ b/stdlib/source/test/lux/control/function/mutual.lux @@ -25,13 +25,13 @@ (-> Nat Bit) (case number 0 true - _ (odd? (dec number))) + _ (odd? (-- number))) (odd? number) (-> Nat Bit) (case number 0 false - _ (even? (dec number)))] + _ (even? (-- number)))] (and (bit\= expected (even? sample)) (bit\= (not expected) (odd? sample))))))) @@ -40,13 +40,13 @@ (-> Nat Bit) (case number 0 true - _ (odd? (dec number)))] + _ (odd? (-- number)))] [(odd? number) (-> Nat Bit) (case number 0 false - _ (even? (dec number)))]) + _ (even? (-- number)))]) (def: test_def Test diff --git a/stdlib/source/test/lux/control/parser.lux b/stdlib/source/test/lux/control/parser.lux index f45ba2111..e37a2f355 100644 --- a/stdlib/source/test/lux/control/parser.lux +++ b/stdlib/source/test/lux/control/parser.lux @@ -195,7 +195,7 @@ (list.first times expected+) actual))) (|> (list\map code.nat expected+) - (/.result (/.exactly (inc variadic) <code>.nat)) + (/.result (/.exactly (++ variadic) <code>.nat)) fails?))) (_.cover [/.at_least] (and (|> (list\map code.nat expected+) @@ -205,7 +205,7 @@ expected+ actual))) (|> (list\map code.nat expected+) - (/.result (/.at_least (inc variadic) <code>.nat)) + (/.result (/.at_least (++ variadic) <code>.nat)) fails?))) (_.cover [/.at_most] (and (|> (list\map code.nat expected+) @@ -215,7 +215,7 @@ (list.first times expected+) actual))) (|> (list\map code.nat expected+) - (/.result (/.at_most (inc variadic) <code>.nat)) + (/.result (/.at_most (++ variadic) <code>.nat)) (match actual (\ (list.equivalence n.equivalence) = expected+ diff --git a/stdlib/source/test/lux/control/parser/binary.lux b/stdlib/source/test/lux/control/parser/binary.lux index 50233ba6e..dcf4d0e80 100644 --- a/stdlib/source/test/lux/control/parser/binary.lux +++ b/stdlib/source/test/lux/control/parser/binary.lux @@ -355,7 +355,7 @@ post)))) (!expect (#try.Success #1))))) (do {! random.monad} - [to_read (\ ! map (n.% (inc ..segment_size)) random.nat) + [to_read (\ ! map (n.% (++ ..segment_size)) random.nat) data (\ ! map (\ utf8.codec encode) (random.ascii ..segment_size))] (_.cover [/.Offset /.offset] (|> data @@ -370,7 +370,7 @@ (n.= ..segment_size nothing_left))))) (!expect (#try.Success #1))))) (do {! random.monad} - [to_read (\ ! map (n.% (inc ..segment_size)) random.nat) + [to_read (\ ! map (n.% (++ ..segment_size)) random.nat) data (\ ! map (\ utf8.codec encode) (random.ascii ..segment_size))] (_.cover [/.remaining] (|> data diff --git a/stdlib/source/test/lux/control/parser/cli.lux b/stdlib/source/test/lux/control/parser/cli.lux index fb1f485c0..529986ad4 100644 --- a/stdlib/source/test/lux/control/parser/cli.lux +++ b/stdlib/source/test/lux/control/parser/cli.lux @@ -57,7 +57,7 @@ (_.cover [/.somewhere] (|> (/.result (|> (/.somewhere (/.this expected)) (<>.before (<>.some /.any))) - (list.joined (list pre_ignore (list expected) post_ignore))) + (list.together (list pre_ignore (list expected) post_ignore))) (!expect (#try.Success _)))) (_.cover [/.end] (and (|> (/.result /.end (list)) diff --git a/stdlib/source/test/lux/control/parser/synthesis.lux b/stdlib/source/test/lux/control/parser/synthesis.lux index 068ba1235..e412ff262 100644 --- a/stdlib/source/test/lux/control/parser/synthesis.lux +++ b/stdlib/source/test/lux/control/parser/synthesis.lux @@ -132,12 +132,12 @@ expected_environment ..random_environment expected_body (random.unicode 1)] (_.cover [/.wrong_arity] - (|> (/.result (/.function (inc arity) /.text) + (|> (/.result (/.function (++ arity) /.text) (list (synthesis.function/abstraction [expected_environment arity (synthesis.text expected_body)]))) (!expect (^multi (#try.Failure error) (exception.match? /.wrong_arity error)))))) (do {! random.monad} - [arity (\ ! map (|>> (n.% 10) inc) random.nat) + [arity (\ ! map (|>> (n.% 10) ++) random.nat) expected_offset random.nat expected_inits (random.list arity random.bit) expected_body (random.unicode 1)] diff --git a/stdlib/source/test/lux/control/parser/text.lux b/stdlib/source/test/lux/control/parser/text.lux index 7be2416d0..951bed82e 100644 --- a/stdlib/source/test/lux/control/parser/text.lux +++ b/stdlib/source/test/lux/control/parser/text.lux @@ -77,7 +77,7 @@ .let [limit (n.+ offset range)] expected (\ ! map (|>> (n.% range) (n.+ offset) text.of_char) random.nat) out_of_range (case offset - 0 (\ ! map (|>> (n.% 10) inc (n.+ limit) text.of_char) random.nat) + 0 (\ ! map (|>> (n.% 10) ++ (n.+ limit) text.of_char) random.nat) _ (\ ! map (|>> (n.% offset) text.of_char) random.nat))] (_.cover [/.range] (and (..should_pass expected (/.range offset limit)) @@ -157,7 +157,7 @@ (random.set n.hash num_options) (\ ! map (|>> set.list (list\map text.of_char) - text.joined))) + text.together))) expected (\ ! map (function (_ value) (|> options (text.char (n.% num_options value)) @@ -183,7 +183,7 @@ (random.set n.hash num_options) (\ ! map (|>> set.list (list\map text.of_char) - text.joined))) + text.together))) invalid (\ ! map (function (_ value) (|> options (text.char (n.% num_options value)) diff --git a/stdlib/source/test/lux/control/parser/type.lux b/stdlib/source/test/lux/control/parser/type.lux index 373d549e9..dc901e3c4 100644 --- a/stdlib/source/test/lux/control/parser/type.lux +++ b/stdlib/source/test/lux/control/parser/type.lux @@ -166,7 +166,7 @@ Test (do {! random.monad} [not_polymorphic ..primitive - expected_inputs (\ ! map (|>> (n.% 10) inc) random.nat)] + expected_inputs (\ ! map (|>> (n.% 10) ++) random.nat)] ($_ _.and (_.cover [/.not_polymorphic] (and (|> (/.result (/.polymorphic /.any) diff --git a/stdlib/source/test/lux/control/parser/xml.lux b/stdlib/source/test/lux/control/parser/xml.lux index 92efb1121..e92216696 100644 --- a/stdlib/source/test/lux/control/parser/xml.lux +++ b/stdlib/source/test/lux/control/parser/xml.lux @@ -164,9 +164,9 @@ (_.cover [/.somewhere] (|> (/.result parser (list (node parent - (list.joined (list (list.repeated repetitions (node wrong (list))) - (list (node right (list))) - (list.repeated repetitions (node wrong (list)))))))) + (list.together (list (list.repeated repetitions (node wrong (list))) + (list (node right (list))) + (list.repeated repetitions (node wrong (list)))))))) (!expect (#try.Success [])))) (_.cover [/.nowhere] (|> (/.result parser diff --git a/stdlib/source/test/lux/control/pipe.lux b/stdlib/source/test/lux/control/pipe.lux index 27e92a7e0..3ef82e309 100644 --- a/stdlib/source/test/lux/control/pipe.lux +++ b/stdlib/source/test/lux/control/pipe.lux @@ -25,11 +25,11 @@ (do ! [another random.nat] (_.cover [/.new>] - (n.= (inc another) + (n.= (++ another) (|> sample (n.* 3) (n.+ 4) - (/.new> another [inc]))))) + (/.new> another [++]))))) (_.cover [/.let>] (n.= (n.+ sample sample) (|> sample @@ -63,12 +63,12 @@ (/.loop> [(n.= (n.* 10 sample)) not] [(n.+ sample)])))) (_.cover [/.do>] - (n.= (inc (n.+ 4 (n.* 3 sample))) + (n.= (++ (n.+ 4 (n.* 3 sample))) (|> sample (/.do> identity.monad [(n.* 3)] [(n.+ 4)] - [inc])))) + [++])))) (_.cover [/.exec>] (n.= (n.* 10 sample) (|> sample @@ -76,11 +76,11 @@ (n.* 10)))) (_.cover [/.tuple>] (let [[left middle right] (|> sample - (/.tuple> [inc] - [dec] + (/.tuple> [++] + [--] [%.nat]))] - (and (n.= (inc sample) left) - (n.= (dec sample) middle) + (and (n.= (++ sample) left) + (n.= (-- sample) middle) (text\= (%.nat sample) right)))) (_.cover [/.case>] (text\= (case (n.% 10 sample) diff --git a/stdlib/source/test/lux/control/region.lux b/stdlib/source/test/lux/control/region.lux index caabbadf6..555f30b4f 100644 --- a/stdlib/source/test/lux/control/region.lux +++ b/stdlib/source/test/lux/control/region.lux @@ -103,7 +103,7 @@ .let [//@ ! count_clean_up (function (_ value) (do ! - [_ (thread.update! inc clean_up_counter)] + [_ (thread.update! ++ clean_up_counter)] (in (#try.Success []))))] outcome (/.run! ! (do {! (/.monad !)} @@ -121,7 +121,7 @@ .let [//@ ! count_clean_up (function (_ value) (do ! - [_ (thread.update! inc clean_up_counter)] + [_ (thread.update! ++ clean_up_counter)] (in (#try.Success []))))] outcome (/.run! ! (do {! (/.monad !)} @@ -140,7 +140,7 @@ .let [//@ ! count_clean_up (function (_ value) (do ! - [_ (thread.update! inc clean_up_counter)] + [_ (thread.update! ++ clean_up_counter)] (in (#try.Success []))))] outcome (/.run! ! (do {! (/.monad !)} @@ -159,7 +159,7 @@ .let [//@ ! count_clean_up (function (_ value) (do ! - [_ (thread.update! inc clean_up_counter)] + [_ (thread.update! ++ clean_up_counter)] (in (: (Try Any) (exception.except ..oops [])))))] outcome (/.run! ! diff --git a/stdlib/source/test/lux/control/state.lux b/stdlib/source/test/lux/control/state.lux index 864c16bd9..eda78cbeb 100644 --- a/stdlib/source/test/lux/control/state.lux +++ b/stdlib/source/test/lux/control/state.lux @@ -46,8 +46,8 @@ [_ (/.update (n.* value))] /.get))) (_.cover [/.use] - (with_conditions [state (inc state)] - (/.use inc))) + (with_conditions [state (++ state)] + (/.use ++))) (_.cover [/.local] (with_conditions [state (n.* value state)] (/.local (n.* value) @@ -88,12 +88,12 @@ (in (n.< limit state)))]] ($_ _.and (_.cover [/.while /.result] - (|> (/.while condition (/.update inc)) + (|> (/.while condition (/.update ++)) (/.result 0) (let> [state' output'] (n.= limit state')))) (_.cover [/.do_while] - (|> (/.do_while condition (/.update inc)) + (|> (/.do_while condition (/.update ++)) (/.result 0) (let> [state' output'] (or (n.= limit state') diff --git a/stdlib/source/test/lux/data/binary.lux b/stdlib/source/test/lux/data/binary.lux index 372aed7de..331e05142 100644 --- a/stdlib/source/test/lux/data/binary.lux +++ b/stdlib/source/test/lux/data/binary.lux @@ -39,7 +39,7 @@ (do random.monad [byte random.nat] (exec (try.trusted (/.write/8! idx byte output)) - (recur (inc idx)))) + (recur (++ idx)))) (\ random.monad in output))))) (def: (throws? exception try) @@ -56,8 +56,8 @@ (let [bytes (i64.left_shifted power 1) binary (/.empty bytes) cap (case bytes - 8 (dec 0) - _ (|> 1 (i64.left_shifted (n.* 8 bytes)) dec)) + 8 (-- 0) + _ (|> 1 (i64.left_shifted (n.* 8 bytes)) --)) capped_value (i64.and cap value)] (and (..succeed (do try.monad @@ -71,9 +71,9 @@ (def: as_list (-> /.Binary (List Nat)) - (/.fold (function (_ head tail) - (#.Item head tail)) - (list))) + (/.aggregate (function (_ head tail) + (#.Item head tail)) + (list))) (def: .public test Test @@ -92,9 +92,9 @@ ($equivalence.spec /.equivalence (..random size))) (_.for [/.monoid] ($monoid.spec /.equivalence /.monoid (..random size))) - (_.cover [/.fold] + (_.cover [/.aggregate] (n.= (\ list.fold fold n.+ 0 (..as_list sample)) - (/.fold n.+ 0 sample))) + (/.aggregate n.+ 0 sample))) (_.cover [/.empty] (\ /.equivalence = @@ -117,7 +117,7 @@ idxs (: (List Nat) (case length 0 (list) - _ (enum.range n.enum 0 (dec length)))) + _ (enum.range n.enum 0 (-- length)))) reader (function (_ binary idx) (/.read/8! idx binary))] (and (n.= length (/.size random_slice)) @@ -143,7 +143,7 @@ (#.Item head tail) (n.= (list.fold n.+ 0 tail) - (/.fold n.+ 0 (/.after 1 sample)))))) + (/.aggregate n.+ 0 (/.after 1 sample)))))) (_.cover [/.copy] (and (case (/.copy size 0 sample 0 (/.empty size)) (#try.Success output) diff --git a/stdlib/source/test/lux/data/collection/array.lux b/stdlib/source/test/lux/data/collection/array.lux index c1e1471f8..4045c008a 100644 --- a/stdlib/source/test/lux/data/collection/array.lux +++ b/stdlib/source/test/lux/data/collection/array.lux @@ -169,14 +169,14 @@ _ false))) (do ! - [occupancy (\ ! map (n.% (inc size)) random.nat)] + [occupancy (\ ! map (n.% (++ size)) random.nat)] (_.cover [/.occupancy /.vacancy] (let [the_array (loop [output (: (Array Nat) (/.empty size)) idx 0] (if (n.< occupancy idx) (recur (/.write! idx expected output) - (inc idx)) + (++ idx)) output))] (and (n.= occupancy (/.occupancy the_array)) (n.= size (n.+ (/.occupancy the_array) @@ -189,7 +189,7 @@ (|> the_array /.list /.of_list (\ (/.equivalence n.equivalence) = the_array))))) (do ! - [amount (\ ! map (n.% (inc size)) random.nat)] + [amount (\ ! map (n.% (++ size)) random.nat)] (_.cover [/.copy!] (let [copy (: (Array Nat) (/.empty size))] diff --git a/stdlib/source/test/lux/data/collection/bits.lux b/stdlib/source/test/lux/data/collection/bits.lux index 6710ef7c6..c0e54e3bb 100644 --- a/stdlib/source/test/lux/data/collection/bits.lux +++ b/stdlib/source/test/lux/data/collection/bits.lux @@ -17,7 +17,7 @@ (def: (size min max) (-> Nat Nat (Random Nat)) (|> random.nat - (\ random.monad map (|>> (n.% (inc max)) (n.max min))))) + (\ random.monad map (|>> (n.% (++ max)) (n.max min))))) (def: .public random (Random Bits) @@ -47,7 +47,7 @@ (/.empty? /.empty)) (do {! random.monad} - [size (\ ! map (|>> (n.% 1,000) inc) random.nat) + [size (\ ! map (|>> (n.% 1,000) ++) random.nat) idx (\ ! map (n.% size) random.nat) sample ..random] ($_ _.and @@ -73,7 +73,7 @@ /.empty)) (/.intersects? (/.one idx /.empty) (/.one idx /.empty)) - (not (/.intersects? (/.one (inc idx) /.empty) + (not (/.intersects? (/.one (++ idx) /.empty) (/.one idx /.empty))) (not (/.intersects? sample (/.not sample))))) (_.cover [/.not] diff --git a/stdlib/source/test/lux/data/collection/dictionary.lux b/stdlib/source/test/lux/data/collection/dictionary.lux index 080e09001..446c4e354 100644 --- a/stdlib/source/test/lux/data/collection/dictionary.lux +++ b/stdlib/source/test/lux/data/collection/dictionary.lux @@ -112,7 +112,7 @@ (let [merging_with_oneself (let [(^open ".") (/.equivalence n.equivalence)] (= dict (/.merged dict dict))) overwritting_keys (let [dict' (|> dict /.entries - (list\map (function (_ [k v]) [k (inc v)])) + (list\map (function (_ [k v]) [k (++ v)])) (/.of_list n.hash)) (^open ".") (/.equivalence n.equivalence)] (= dict' (/.merged dict' dict)))] @@ -155,7 +155,7 @@ _ true))) (_.cover [/.has] - (and (n.= (inc (/.size dict)) + (and (n.= (++ (/.size dict)) (/.size (/.has non_key test_val dict))) (case (/.value non_key (/.has non_key test_val dict)) (#.Some v) (n.= test_val v) @@ -193,24 +193,24 @@ true (#.Some known_key) - (n.= (dec (/.size dict)) + (n.= (-- (/.size dict)) (/.size (/.lacks known_key dict)))))) (_.cover [/.revised] (let [base (/.has non_key test_val dict) - updt (/.revised non_key inc base)] + updt (/.revised non_key ++ base)] (case [(/.value non_key base) (/.value non_key updt)] [(#.Some x) (#.Some y)] - (n.= (inc x) y) + (n.= (++ x) y) _ false))) (_.cover [/.revised'] (let [can_upsert_new_key! - (case (/.value non_key (/.revised' non_key test_val inc dict)) + (case (/.value non_key (/.revised' non_key test_val ++ dict)) (#.Some inserted) - (n.= (inc test_val) inserted) + (n.= (++ test_val) inserted) #.None false) @@ -221,9 +221,9 @@ true (#.Some [known_key known_value]) - (case (/.value known_key (/.revised' known_key test_val inc dict)) + (case (/.value known_key (/.revised' known_key test_val ++ dict)) (#.Some updated) - (n.= (inc known_value) updated) + (n.= (++ known_value) updated) #.None false))] diff --git a/stdlib/source/test/lux/data/collection/dictionary/ordered.lux b/stdlib/source/test/lux/data/collection/dictionary/ordered.lux index 838d2cf5d..7f6178f8e 100644 --- a/stdlib/source/test/lux/data/collection/dictionary/ordered.lux +++ b/stdlib/source/test/lux/data/collection/dictionary/ordered.lux @@ -32,7 +32,7 @@ _ (do random.monad - [partial (dictionary order gen_key gen_value (dec size)) + [partial (dictionary order gen_key gen_value (-- size)) key (random.only (|>> (/.key? partial) not) gen_key) value gen_value] @@ -111,7 +111,7 @@ (and (not (/.key? sample extra_key)) (let [sample+ (/.has extra_key extra_value sample)] (and (/.key? sample+ extra_key) - (n.= (inc (/.size sample)) + (n.= (++ (/.size sample)) (/.size sample+)))))) (_.cover [/.value] (let [sample+ (/.has extra_key extra_value sample)] diff --git a/stdlib/source/test/lux/data/collection/dictionary/plist.lux b/stdlib/source/test/lux/data/collection/dictionary/plist.lux index c76892185..2172fbd44 100644 --- a/stdlib/source/test/lux/data/collection/dictionary/plist.lux +++ b/stdlib/source/test/lux/data/collection/dictionary/plist.lux @@ -69,7 +69,7 @@ (let [sample+ (/.has extra_key extra_value sample)] (and (not (/.contains? extra_key sample)) (/.contains? extra_key sample+) - (n.= (inc (/.size sample)) + (n.= (++ (/.size sample)) (/.size sample+))))) (_.cover [/.value] (|> sample diff --git a/stdlib/source/test/lux/data/collection/list.lux b/stdlib/source/test/lux/data/collection/list.lux index 8ba430845..f635eca05 100644 --- a/stdlib/source/test/lux/data/collection/list.lux +++ b/stdlib/source/test/lux/data/collection/list.lux @@ -146,7 +146,7 @@ (/.sorted n.< indices)) expected_numbers! - (/.every? (n.= (dec size)) + (/.every? (n.= (-- size)) (/.zipped_with/2 n.+ indices (/.sorted n.> indices)))] @@ -185,7 +185,7 @@ ..random) .let [size (/.size sample)] idx (\ ! map (n.% size) random.nat) - sub_size (\ ! map (|>> (n.% size) inc) random.nat)] + sub_size (\ ! map (|>> (n.% size) ++) random.nat)] ($_ _.and (_.cover [/.only] (let [positives (/.only n.even? sample) @@ -222,7 +222,7 @@ (let [subs (/.sub sub_size sample)] (and (/.every? (|>> /.size (n.<= sub_size)) subs) (/\= sample - (/.joined subs))))) + (/.together subs))))) )))) (def: member @@ -341,11 +341,11 @@ ((/.zipped_with 2) +/2 sample/0 sample/1)) (/\= (/.zipped_with/3 +/3 sample/0 sample/1 sample/2) ((/.zipped_with 3) +/3 sample/0 sample/1 sample/2)))) - (_.cover [/.joined] + (_.cover [/.together] (and (/\= (/\compose sample/0 sample/1) - (/.joined (list sample/0 sample/1))) + (/.together (list sample/0 sample/1))) (/\= ($_ /\compose sample/0 sample/1 sample/2) - (/.joined (list sample/0 sample/1 sample/2))))) + (/.together (list sample/0 sample/1 sample/2))))) )))) (def: search @@ -410,7 +410,7 @@ (_.cover [/.interposed] (or (/.empty? sample) (let [sample+ (/.interposed separator sample)] - (and (n.= (|> (/.size sample) (n.* 2) dec) + (and (n.= (|> (/.size sample) (n.* 2) --) (/.size sample+)) (|> sample+ /.pairs (/.every? (|>> product.right (n.= separator)))))))) (_.cover [/.iterations] @@ -419,14 +419,14 @@ (/\= (/.indices size) (/.iterations (function (_ index) (if (n.< size index) - (#.Some (inc index)) + (#.Some (++ index)) #.None)) 0))))) - (_.cover [/.folds] + (_.cover [/.aggregates] (/\= (/\map (function (_ index) (\ /.fold fold n.+ 0 (/.first index sample))) - (/.indices (inc (/.size sample)))) - (/.folds n.+ 0 sample))) + (/.indices (++ (/.size sample)))) + (/.aggregates n.+ 0 sample))) (do random.monad [expected random.nat .let [(^open "/\.") (/.equivalence n.equivalence)]] diff --git a/stdlib/source/test/lux/data/collection/queue.lux b/stdlib/source/test/lux/data/collection/queue.lux index 5fcec5102..cdb7198b5 100644 --- a/stdlib/source/test/lux/data/collection/queue.lux +++ b/stdlib/source/test/lux/data/collection/queue.lux @@ -81,7 +81,7 @@ (let [pushed (/.end non_member sample) size_increases! - (n.= (inc (/.size sample)) (/.size pushed)) + (n.= (++ (/.size sample)) (/.size pushed)) new_member_is_identified! (/.member? n.equivalence pushed non_member) @@ -99,7 +99,7 @@ (let [popped (/.next sample) size_decreases! - (n.= (dec (/.size sample)) + (n.= (-- (/.size sample)) (/.size popped)) popped_member_is_not_identified! diff --git a/stdlib/source/test/lux/data/collection/queue/priority.lux b/stdlib/source/test/lux/data/collection/queue/priority.lux index 4faaaf488..9be7c183f 100644 --- a/stdlib/source/test/lux/data/collection/queue/priority.lux +++ b/stdlib/source/test/lux/data/collection/queue/priority.lux @@ -64,14 +64,14 @@ (_.cover [/.end] (let [sample+ (/.end non_member_priority non_member sample)] (and (not (/.member? n.equivalence sample non_member)) - (n.= (inc (/.size sample)) + (n.= (++ (/.size sample)) (/.size sample+)) (/.member? n.equivalence sample+ non_member)))) (_.cover [/.next] (let [sample- (/.next sample)] (or (and (/.empty? sample) (/.empty? sample-)) - (n.= (dec (/.size sample)) + (n.= (-- (/.size sample)) (/.size sample-))))) (_.for [/.Priority] ($_ _.and diff --git a/stdlib/source/test/lux/data/collection/row.lux b/stdlib/source/test/lux/data/collection/row.lux index 2515f284f..8e8348617 100644 --- a/stdlib/source/test/lux/data/collection/row.lux +++ b/stdlib/source/test/lux/data/collection/row.lux @@ -81,7 +81,7 @@ (def: index_based Test (do {! random.monad} - [size (\ ! map (|>> (n.% 100) inc) random.nat)] + [size (\ ! map (|>> (n.% 100) ++) random.nat)] ($_ _.and (do ! [good_index (|> random.nat (\ ! map (n.% size))) @@ -108,9 +108,9 @@ (<| (try.else false) (do try.monad [sample (/.has good_index non_member sample) - sample (/.revised good_index inc sample) + sample (/.revised good_index ++ sample) actual (/.item good_index sample)] - (in (n.= (inc non_member) actual))))) + (in (n.= (++ non_member) actual))))) (_.cover [/.within_bounds?] (and (/.within_bounds? sample good_index) (not (/.within_bounds? sample bad_index)))) @@ -125,7 +125,7 @@ (exception.match? /.index_out_of_bounds error))))] (and (fails! (/.item bad_index sample)) (fails! (/.has bad_index non_member sample)) - (fails! (/.revised bad_index inc sample))))) + (fails! (/.revised bad_index ++ sample))))) )) ))) @@ -134,7 +134,7 @@ (<| (_.covering /._) (_.for [/.Row]) (do {! random.monad} - [size (\ ! map (|>> (n.% 100) inc) random.nat)] + [size (\ ! map (|>> (n.% 100) ++) random.nat)] ($_ _.and ..signatures ..whole @@ -158,28 +158,28 @@ (and (list.every? (/.member? n.equivalence sample) (/.list sample)) (not (/.member? n.equivalence sample non_member)))) - (_.cover [/.add] - (let [added (/.add non_member sample) + (_.cover [/.suffix] + (let [added (/.suffix non_member sample) size_increases! - (n.= (inc (/.size sample)) + (n.= (++ (/.size sample)) (/.size added)) is_a_member! (/.member? n.equivalence added non_member)] (and size_increases! is_a_member!))) - (_.cover [/.pop] + (_.cover [/.prefix] (if (/.empty? sample) - (/.empty? (/.pop sample)) + (/.empty? (/.prefix sample)) (let [expected_size! - (n.= (dec (/.size sample)) - (/.size (/.pop sample))) + (n.= (-- (/.size sample)) + (/.size (/.prefix sample))) symmetry! (|> sample - (/.add non_member) - /.pop + (/.suffix non_member) + /.prefix (/\= sample))] (and expected_size! symmetry!)))) diff --git a/stdlib/source/test/lux/data/collection/sequence.lux b/stdlib/source/test/lux/data/collection/sequence.lux index ebac1772b..fc67cf27d 100644 --- a/stdlib/source/test/lux/data/collection/sequence.lux +++ b/stdlib/source/test/lux/data/collection/sequence.lux @@ -46,7 +46,7 @@ (do {! random.monad} [repeated random.nat index (\ ! map (n.% 100) random.nat) - size (\ ! map (|>> (n.% 10) inc) random.nat) + size (\ ! map (|>> (n.% 10) ++) random.nat) offset (\ ! map (n.% 100) random.nat) cycle_start random.nat cycle_next (random.list size random.nat)] @@ -58,65 +58,65 @@ (_.cover [/.item] (n.= (n.+ offset index) - (/.item index (..iterations inc offset)))) + (/.item index (..iterations ++ offset)))) (_.cover [/.repeated] (n.= repeated (/.item index (/.repeated repeated)))) (_.cover [/.first] - (list\= (enum.range n.enum offset (dec (n.+ size offset))) - (/.first size (..iterations inc offset)))) + (list\= (enum.range n.enum offset (-- (n.+ size offset))) + (/.first size (..iterations ++ offset)))) (_.cover [/.after] - (list\= (enum.range n.enum offset (dec (n.+ size offset))) - (/.first size (/.after offset (..iterations inc 0))))) + (list\= (enum.range n.enum offset (-- (n.+ size offset))) + (/.first size (/.after offset (..iterations ++ 0))))) (_.cover [/.split_at] - (let [[drops takes] (/.split_at size (..iterations inc 0))] - (and (list\= (enum.range n.enum 0 (dec size)) + (let [[drops takes] (/.split_at size (..iterations ++ 0))] + (and (list\= (enum.range n.enum 0 (-- size)) drops) - (list\= (enum.range n.enum size (dec (n.* 2 size))) + (list\= (enum.range n.enum size (-- (n.* 2 size))) (/.first size takes))))) (_.cover [/.while] - (list\= (enum.range n.enum 0 (dec size)) - (/.while (n.< size) (..iterations inc 0)))) + (list\= (enum.range n.enum 0 (-- size)) + (/.while (n.< size) (..iterations ++ 0)))) (_.cover [/.until] - (list\= (enum.range n.enum offset (dec (n.+ size offset))) + (list\= (enum.range n.enum offset (-- (n.+ size offset))) (/.while (n.< (n.+ size offset)) - (/.until (n.< offset) (..iterations inc 0))))) + (/.until (n.< offset) (..iterations ++ 0))))) (_.cover [/.split_when] - (let [[drops takes] (/.split_when (n.= size) (..iterations inc 0))] - (and (list\= (enum.range n.enum 0 (dec size)) + (let [[drops takes] (/.split_when (n.= size) (..iterations ++ 0))] + (and (list\= (enum.range n.enum 0 (-- size)) drops) - (list\= (enum.range n.enum size (dec (n.* 2 size))) + (list\= (enum.range n.enum size (-- (n.* 2 size))) (/.while (n.< (n.* 2 size)) takes))))) (_.cover [/.head] (n.= offset - (/.head (..iterations inc offset)))) + (/.head (..iterations ++ offset)))) (_.cover [/.tail] - (list\= (enum.range n.enum (inc offset) (n.+ size offset)) - (/.first size (/.tail (..iterations inc offset))))) + (list\= (enum.range n.enum (++ offset) (n.+ size offset)) + (/.first size (/.tail (..iterations ++ offset))))) (_.cover [/.only] - (list\= (list\map (n.* 2) (enum.range n.enum 0 (dec size))) - (/.first size (/.only n.even? (..iterations inc 0))))) + (list\= (list\map (n.* 2) (enum.range n.enum 0 (-- size))) + (/.first size (/.only n.even? (..iterations ++ 0))))) (_.cover [/.partition] - (let [[evens odds] (/.partition n.even? (..iterations inc 0))] + (let [[evens odds] (/.partition n.even? (..iterations ++ 0))] (and (n.= (n.* 2 offset) (/.item offset evens)) - (n.= (inc (n.* 2 offset)) + (n.= (++ (n.* 2 offset)) (/.item offset odds))))) (_.cover [/.iterations] (let [(^open "/\.") /.functor (^open "list\.") (list.equivalence text.equivalence)] (list\= (/.first size - (/\map %.nat (..iterations inc offset))) + (/\map %.nat (..iterations ++ offset))) (/.first size - (/.iterations (function (_ n) [(inc n) (%.nat n)]) + (/.iterations (function (_ n) [(++ n) (%.nat n)]) offset))))) (_.cover [/.cycle] (let [cycle (list& cycle_start cycle_next)] - (list\= (list.joined (list.repeated size cycle)) + (list\= (list.together (list.repeated size cycle)) (/.first (n.* size (list.size cycle)) (/.cycle [cycle_start cycle_next]))))) (_.cover [/.^sequence&] - (let [(/.^sequence& first second third next) (..iterations inc offset)] + (let [(/.^sequence& first second third next) (..iterations ++ offset)] (and (n.= offset first) (n.= (n.+ 1 offset) second) (n.= (n.+ 2 offset) third)))) diff --git a/stdlib/source/test/lux/data/collection/set.lux b/stdlib/source/test/lux/data/collection/set.lux index e6dbd5c3d..66ecd0ca3 100644 --- a/stdlib/source/test/lux/data/collection/set.lux +++ b/stdlib/source/test/lux/data/collection/set.lux @@ -80,7 +80,7 @@ (/.member? (/.has non_memberL setL) non_memberL) size_increase! - (n.= (inc (/.size setL)) + (n.= (++ (/.size setL)) (/.size (/.has non_memberL setL)))] (and before_addition! after_addition!))) diff --git a/stdlib/source/test/lux/data/collection/set/multi.lux b/stdlib/source/test/lux/data/collection/set/multi.lux index 09c7c2cd5..4ca359ddb 100644 --- a/stdlib/source/test/lux/data/collection/set/multi.lux +++ b/stdlib/source/test/lux/data/collection/set/multi.lux @@ -23,7 +23,7 @@ (def: count (Random Nat) - (\ random.monad map (|>> (n.% 10) inc) random.nat)) + (\ random.monad map (|>> (n.% 10) ++) random.nat)) (def: .public (random size hash count element) (All [a] (-> Nat (Hash a) (Random Nat) (Random a) (Random (/.Set a)))) diff --git a/stdlib/source/test/lux/data/collection/set/ordered.lux b/stdlib/source/test/lux/data/collection/set/ordered.lux index 725c4b3c0..b753ac1af 100644 --- a/stdlib/source/test/lux/data/collection/set/ordered.lux +++ b/stdlib/source/test/lux/data/collection/set/ordered.lux @@ -31,7 +31,7 @@ _ (do random.monad - [partial (random (dec size) &order gen_value) + [partial (random (-- size) &order gen_value) value (random.only (|>> (/.member? partial) not) gen_value)] (in (/.has value partial))))) @@ -95,7 +95,7 @@ (let [setL+ (/.has non_memberL setL)] (and (not (/.member? setL non_memberL)) (/.member? setL+ non_memberL) - (n.= (inc (/.size setL)) + (n.= (++ (/.size setL)) (/.size setL+))))) (_.cover [/.lacks] (|> setL diff --git a/stdlib/source/test/lux/data/collection/tree/zipper.lux b/stdlib/source/test/lux/data/collection/tree/zipper.lux index a4e73fb03..2b20582e9 100644 --- a/stdlib/source/test/lux/data/collection/tree/zipper.lux +++ b/stdlib/source/test/lux/data/collection/tree/zipper.lux @@ -188,9 +188,9 @@ (n.= expected))) (_.cover [/.update] (|> (/.zipper (tree.leaf expected)) - (/.update inc) + (/.update ++) /.value - (n.= (inc expected)))) + (n.= (++ expected)))) ..move (_.cover [/.end?] (or (/.end? (/.zipper sample)) diff --git a/stdlib/source/test/lux/data/color.lux b/stdlib/source/test/lux/data/color.lux index a4fc0911e..67158dc10 100644 --- a/stdlib/source/test/lux/data/color.lux +++ b/stdlib/source/test/lux/data/color.lux @@ -135,7 +135,7 @@ random.safe_frac) .let [eS +0.5] variations (\ ! map (|>> (n.% 3) (n.+ 2)) random.nat) - .let [max_spread (f./ (|> variations inc .int int.frac) + .let [max_spread (f./ (|> variations ++ .int int.frac) +1.0) min_spread (f./ +2.0 max_spread) spread_space (f.- min_spread max_spread)] @@ -206,8 +206,8 @@ (_.for [/.Alpha /.Pigment] ($_ _.and (_.cover [/.transparent /.opaque] - (and (r.= /.opaque (dec /.transparent)) - (r.= /.transparent (inc /.opaque)))) + (and (r.= /.opaque (-- /.transparent)) + (r.= /.transparent (++ /.opaque)))) (_.cover [/.translucent] (r.= /.transparent (r.+ /.translucent /.translucent))) )) diff --git a/stdlib/source/test/lux/data/color/named.lux b/stdlib/source/test/lux/data/color/named.lux index aaf1fcab8..4e400e99c 100644 --- a/stdlib/source/test/lux/data/color/named.lux +++ b/stdlib/source/test/lux/data/color/named.lux @@ -201,13 +201,13 @@ /.yellow_green]] )] (def: all_colors - (list.joined (`` (list (~~ (template [<definition> <by_letter>] - [((: (-> Any (List //.Color)) - (function (_ _) - (`` (list (~~ (template.spliced <by_letter>)))))) - 123)] - - <colors>)))))) + (list.together (`` (list (~~ (template [<definition> <by_letter>] + [((: (-> Any (List //.Color)) + (function (_ _) + (`` (list (~~ (template.spliced <by_letter>)))))) + 123)] + + <colors>)))))) (def: unique_colors (set.of_list //.hash ..all_colors)) diff --git a/stdlib/source/test/lux/data/format/tar.lux b/stdlib/source/test/lux/data/format/tar.lux index fe0083c95..9bed1f5ed 100644 --- a/stdlib/source/test/lux/data/format/tar.lux +++ b/stdlib/source/test/lux/data/format/tar.lux @@ -41,7 +41,7 @@ (_.for [/.Path] (do {! random.monad} [expected (random.ascii/lower /.path_size) - invalid (random.ascii/lower (inc /.path_size)) + invalid (random.ascii/lower (++ /.path_size)) not_ascii (random.text (random.char (unicode.set [unicode/block.katakana (list)])) /.path_size)] (`` ($_ _.and @@ -76,7 +76,7 @@ (_.for [/.Name] (do {! random.monad} [expected (random.ascii/lower /.name_size) - invalid (random.ascii/lower (inc /.name_size)) + invalid (random.ascii/lower (++ /.name_size)) not_ascii (random.text (random.char (unicode.set [unicode/block.katakana (list)])) /.name_size)] (`` ($_ _.and @@ -157,14 +157,14 @@ (def: entry Test (do {! random.monad} - [expected_path (random.ascii/lower (dec /.path_size)) + [expected_path (random.ascii/lower (-- /.path_size)) expected_moment (\ ! map (|>> (n.% 1,0,00,00,00,00,000) .int instant.of_millis) random.nat) chunk (random.ascii/lower chunk_size) chunks (\ ! map (n.% 100) random.nat) .let [content (|> chunk (list.repeated chunks) - text.joined + text.together (\ utf8.codec encode))]] (`` ($_ _.and (~~ (template [<type> <tag>] @@ -317,7 +317,7 @@ (do {! random.monad} [path (random.ascii/lower /.path_size) expected (random.ascii/lower /.name_size) - invalid (random.ascii/lower (inc /.name_size)) + invalid (random.ascii/lower (++ /.name_size)) not_ascii (random.text (random.char (unicode.set [unicode/block.katakana (list)])) /.name_size)] (_.for [/.Ownership /.Owner /.ID] @@ -354,9 +354,9 @@ (in (case (row.list tar) (^ (list (#/.Normal [_ _ _ actual_ownership _]))) (and (text\= (/.from_name expected) - (/.from_name (get@ [#/.user #/.name] actual_ownership))) + (/.from_name (value@ [#/.user #/.name] actual_ownership))) (text\= (/.from_name /.anonymous) - (/.from_name (get@ [#/.group #/.name] actual_ownership)))) + (/.from_name (value@ [#/.group #/.name] actual_ownership)))) _ false))) @@ -378,13 +378,13 @@ (in (case (row.list tar) (^ (list (#/.Normal [_ _ _ actual_ownership _]))) (and (text\= (/.from_name /.anonymous) - (/.from_name (get@ [#/.user #/.name] actual_ownership))) + (/.from_name (value@ [#/.user #/.name] actual_ownership))) (n.= (/.from_small /.no_id) - (/.from_small (get@ [#/.user #/.id] actual_ownership))) + (/.from_small (value@ [#/.user #/.id] actual_ownership))) (text\= (/.from_name /.anonymous) - (/.from_name (get@ [#/.group #/.name] actual_ownership))) + (/.from_name (value@ [#/.group #/.name] actual_ownership))) (n.= (/.from_small /.no_id) - (/.from_small (get@ [#/.group #/.id] actual_ownership)))) + (/.from_small (value@ [#/.group #/.id] actual_ownership)))) _ false))) diff --git a/stdlib/source/test/lux/data/product.lux b/stdlib/source/test/lux/data/product.lux index 9d9b9e248..b779678af 100644 --- a/stdlib/source/test/lux/data/product.lux +++ b/stdlib/source/test/lux/data/product.lux @@ -40,8 +40,8 @@ (n.= expected (/.left [expected dummy]))) (<| (_.cover [/.right]) (n.= expected (/.right [dummy expected]))) - (<| (_.cover [/.fork]) - (let [[left right] ((/.fork (n.+ shift) (n.- shift)) expected)] + (<| (_.cover [/.forked]) + (let [[left right] ((/.forked (n.+ shift) (n.- shift)) expected)] (and (n.= (n.+ shift expected) left) (n.= (n.- shift expected) @@ -62,8 +62,8 @@ (<| (_.cover [/.curried]) (n.= (n.+ left right) ((/.curried (/.uncurried n.+)) left right))) - (<| (_.cover [/.apply]) - (let [[left' right'] (/.apply (n.+ shift) (n.- shift) [left right])] + (<| (_.cover [/.then]) + (let [[left' right'] (/.then (n.+ shift) (n.- shift) [left right])] (and (n.= (n.+ shift left) left') (n.= (n.- shift right) right')))))) )))) diff --git a/stdlib/source/test/lux/data/sum.lux b/stdlib/source/test/lux/data/sum.lux index ddb924273..61b9c43a1 100644 --- a/stdlib/source/test/lux/data/sum.lux +++ b/stdlib/source/test/lux/data/sum.lux @@ -60,14 +60,14 @@ (: (Or Nat Nat)) (/.either (n.+ shift) (n.- shift)) (n.= (n.- shift expected))))) - (_.cover [/.apply] + (_.cover [/.then] (and (|> (/.left expected) (: (Or Nat Nat)) - (/.apply (n.+ shift) (n.- shift)) + (/.then (n.+ shift) (n.- shift)) (case> (0 #0 actual) (n.= (n.+ shift expected) actual) _ false)) (|> (/.right expected) (: (Or Nat Nat)) - (/.apply (n.+ shift) (n.- shift)) + (/.then (n.+ shift) (n.- shift)) (case> (0 #1 actual) (n.= (n.- shift expected) actual) _ false)))) (do ! [size (\ ! map (n.% 5) random.nat) diff --git a/stdlib/source/test/lux/data/text.lux b/stdlib/source/test/lux/data/text.lux index aa012a5ae..51849d1af 100644 --- a/stdlib/source/test/lux/data/text.lux +++ b/stdlib/source/test/lux/data/text.lux @@ -57,7 +57,7 @@ left (random.unicode 1) right (random.unicode 1) .let [full (\ /.monoid compose inner outer) - fake_index (dec 0)]] + fake_index (-- 0)]] (`` ($_ _.and (~~ (template [<affix> <predicate>] [(_.cover [<affix> <predicate>] @@ -83,7 +83,7 @@ [inner (random.unicode 1) outer (random.only (|>> (\ /.equivalence = inner) not) (random.unicode 1)) - .let [fake_index (dec 0)]] + .let [fake_index (-- 0)]] ($_ _.and (_.cover [/.contains?] (let [full (\ /.monoid compose inner outer)] @@ -146,9 +146,9 @@ (\ /.equivalence = /.new_line /.line_feed)) ))) (do {! random.monad} - [size (\ ! map (|>> (n.% 10) inc) random.nat) + [size (\ ! map (|>> (n.% 10) ++) random.nat) characters (random.set /.hash size (random.ascii/alpha 1)) - .let [sample (|> characters set.list /.joined)] + .let [sample (|> characters set.list /.together)] expected (\ ! map (n.% size) random.nat)] (_.cover [/.char] (case (/.char expected sample) @@ -182,7 +182,7 @@ characters (random.set /.hash size (random.ascii/alpha 1)) separator (random.only (|>> (set.member? characters) not) (random.ascii/alpha 1)) - .let [with_no_separator (|> characters set.list /.joined)] + .let [with_no_separator (|> characters set.list /.together)] static (random.ascii/alpha 1) .let [dynamic (random.only (|>> (\ /.equivalence = static) not) (random.ascii/alpha 1))] @@ -192,9 +192,9 @@ lower (random.ascii/lower 1) upper (random.ascii/upper 1)] ($_ _.and - (_.cover [/.joined] + (_.cover [/.together] (n.= (set.size characters) - (/.size (/.joined (set.list characters))))) + (/.size (/.together (set.list characters))))) (_.cover [/.interposed /.all_split_by] (and (|> (set.list characters) (/.interposed separator) @@ -202,7 +202,7 @@ (set.of_list /.hash) (\ set.equivalence = characters)) (\ /.equivalence = - (/.joined (set.list characters)) + (/.together (set.list characters)) (/.interposed "" (set.list characters))))) (_.cover [/.replaced/1] (\ /.equivalence = @@ -285,7 +285,7 @@ sampleL (random.unicode sizeL) sampleR (random.unicode sizeR) middle (random.unicode 1) - .let [sample (/.joined (list sampleL sampleR)) + .let [sample (/.together (list sampleL sampleR)) (^open "/\.") /.equivalence]] ($_ _.and (_.cover [/.split_at] @@ -293,7 +293,7 @@ (case> (#.Right [_l _r]) (and (/\= sampleL _l) (/\= sampleR _r) - (/\= sample (/.joined (list _l _r)))) + (/\= sample (/.together (list _l _r)))) _ #0))) @@ -323,8 +323,8 @@ .let [part_gen (|> (random.text normal_char_gen sizeP) (random.only (|>> (/.contains? sep1) not)))] parts (random.list sizeL part_gen) - .let [sample1 (/.joined (list.interposed sep1 parts)) - sample2 (/.joined (list.interposed sep2 parts)) + .let [sample1 (/.together (list.interposed sep1 parts)) + sample2 (/.together (list.interposed sep2 parts)) (^open "/\.") /.equivalence]] (_.cover [/.replaced] (/\= sample2 diff --git a/stdlib/source/test/lux/data/text/buffer.lux b/stdlib/source/test/lux/data/text/buffer.lux index 393a20779..7d502d2fb 100644 --- a/stdlib/source/test/lux/data/text/buffer.lux +++ b/stdlib/source/test/lux/data/text/buffer.lux @@ -17,7 +17,7 @@ (def: part (Random Text) (do {! random.monad} - [size (\ ! map (|>> (n.% 10) inc) random.nat)] + [size (\ ! map (|>> (n.% 10) ++) random.nat)] (random.ascii/alpha size))) (def: .public test @@ -31,14 +31,14 @@ ($_ _.and (_.cover [/.empty] (n.= 0(/.size /.empty))) - (_.cover [/.size /.append] + (_.cover [/.size /.then] (n.= (text.size left) - (/.size (/.append left /.empty)))) + (/.size (/.then left /.empty)))) (_.cover [/.text] (text\= (format left mid right) (|> /.empty - (/.append left) - (/.append mid) - (/.append right) + (/.then left) + (/.then mid) + (/.then right) /.text))) )))) diff --git a/stdlib/source/test/lux/data/text/encoding.lux b/stdlib/source/test/lux/data/text/encoding.lux index 46dba6ded..432e98257 100644 --- a/stdlib/source/test/lux/data/text/encoding.lux +++ b/stdlib/source/test/lux/data/text/encoding.lux @@ -190,7 +190,7 @@ <encodings>)] (def: all_encodings - (list.joined (list <named>))) + (list.together (list <named>))) (def: unique_encodings (list\fold (function (_ encoding set) diff --git a/stdlib/source/test/lux/data/text/escape.lux b/stdlib/source/test/lux/data/text/escape.lux index dcb562a3e..707a06996 100644 --- a/stdlib/source/test/lux/data/text/escape.lux +++ b/stdlib/source/test/lux/data/text/escape.lux @@ -44,15 +44,15 @@ (def: over_range (Random Char) - (..range (hex "FFFF") (inc (debug.private /.ascii_top)))) + (..range (hex "FFFF") (++ (debug.private /.ascii_top)))) (def: in_range (Random Char) - (..range (inc (debug.private /.ascii_top)) (debug.private /.ascii_bottom))) + (..range (++ (debug.private /.ascii_top)) (debug.private /.ascii_bottom))) (def: ascii_range (Random Char) - (..range (inc (debug.private /.ascii_top)) 0)) + (..range (++ (debug.private /.ascii_top)) 0)) (def: valid_sigils (Set Char) diff --git a/stdlib/source/test/lux/data/text/unicode/block.lux b/stdlib/source/test/lux/data/text/unicode/block.lux index db419c3dc..926a56446 100644 --- a/stdlib/source/test/lux/data/text/unicode/block.lux +++ b/stdlib/source/test/lux/data/text/unicode/block.lux @@ -157,7 +157,7 @@ [(def: <definition> Test (`` (_.cover [(~~ (template.spliced <part>))] - (let [all (list.joined (list <named>)) + (let [all (list.together (list <named>)) unique (set.of_list /.hash all)] (n.= (list.size all) (set.size unique))))))] @@ -173,7 +173,7 @@ [.let [top_start (hex "AC00") top_end (hex "D7AF") end_range (n.- top_start top_end)] - start (\ ! map (|>> (n.% top_start) inc) random.nat) + start (\ ! map (|>> (n.% top_start) ++) random.nat) end (\ ! map (|>> (n.% end_range) (n.+ top_start)) random.nat) .let [additional (n.- start end) sample (/.block start additional) @@ -199,12 +199,12 @@ (n.= end (/.end sample))) (_.cover [/.size] - (n.= (inc additional) + (n.= (++ additional) (/.size sample))) (_.cover [/.within?] (and (/.within? sample inside) - (not (/.within? sample (dec (/.start sample)))) - (not (/.within? sample (inc (/.end sample)))))) + (not (/.within? sample (-- (/.start sample)))) + (not (/.within? sample (++ (/.end sample)))))) (~~ (template [<definition> <part>] [<definition>] diff --git a/stdlib/source/test/lux/data/text/unicode/set.lux b/stdlib/source/test/lux/data/text/unicode/set.lux index 84ebef798..b0be9c914 100644 --- a/stdlib/source/test/lux/data/text/unicode/set.lux +++ b/stdlib/source/test/lux/data/text/unicode/set.lux @@ -80,8 +80,8 @@ end (/.end <set>)]] (_.cover [<set>] (and (/.member? <set> char) - (not (/.member? <set> (dec start))) - (not (/.member? <set> (inc end))))))] + (not (/.member? <set> (-- start))) + (not (/.member? <set> (++ end))))))] [/.ascii] [/.ascii/alpha] diff --git a/stdlib/source/test/lux/documentation.lux b/stdlib/source/test/lux/documentation.lux index 72417f5c5..6efd24021 100644 --- a/stdlib/source/test/lux/documentation.lux +++ b/stdlib/source/test/lux/documentation.lux @@ -54,19 +54,19 @@ (_.cover [/.default] (let [definition (`` (/.default (~~ (template.identifier [.._] [g!default]))))] (and (|> definition - (get@ #/.definition) + (value@ #/.definition) (text\= (template.text [g!default]))) (|> definition - (get@ #/.documentation) + (value@ #/.documentation) md.markdown (text\= "") not)))) (_.cover [/.documentation:] (and (|> ..documentation: - (get@ #/.definition) + (value@ #/.definition) (text\= (template.text [/.documentation:]))) (|> ..documentation: - (get@ #/.documentation) + (value@ #/.documentation) md.markdown (text.contains? 'definition_description')))) )) @@ -87,12 +87,12 @@ (/.documentation super)) (text.contains? (template.text ['super_description']) (/.documentation super)) - (text.contains? (md.markdown (get@ #/.documentation ..documentation:)) + (text.contains? (md.markdown (value@ #/.documentation ..documentation:)) (/.documentation super))))) )) (_.cover [/.unqualified_identifier] (`` (and (~~ (template [<example>] - [(<| (text.contains? (get@ #exception.label /.unqualified_identifier)) + [(<| (text.contains? (value@ #exception.label /.unqualified_identifier)) macro_error <example>)] diff --git a/stdlib/source/test/lux/ffi.jvm.lux b/stdlib/source/test/lux/ffi.jvm.lux index 55c812d72..41a794c4e 100644 --- a/stdlib/source/test/lux/ffi.jvm.lux +++ b/stdlib/source/test/lux/ffi.jvm.lux @@ -110,24 +110,24 @@ idx (|> random.nat (\ ! map (n.% size))) value (\ ! map (|>> (:as java/lang/Long)) random.int)] ($_ _.and - (_.cover [/.array /.array_length] + (_.cover [/.array /.length] (|> size (/.array java/lang/Long) - /.array_length + /.length (n.= size))) - (_.cover [/.array_write /.array_read] + (_.cover [/.write! /.read!] (|> (/.array java/lang/Long size) - (/.array_write idx value) - (/.array_read idx) + (/.write! idx value) + (/.read! idx) (:as Int) (i.= (:as Int value)))) (_.cover [/.cannot_convert_to_jvm_type] (let [array (:as (Array Nothing) (array.empty 1))] (|> array - /.array_length + /.length ..macro_error - (text.contains? (get@ #exception.label /.cannot_convert_to_jvm_type)))))))) + (text.contains? (value@ #exception.label /.cannot_convert_to_jvm_type)))))))) (def: for_miscellaneous Test @@ -198,7 +198,7 @@ [/.Character /.char character character\=] )) (_.cover [/.cannot_cast_to_non_object] - (text.contains? (get@ #exception.label /.cannot_cast_to_non_object) + (text.contains? (value@ #exception.label /.cannot_cast_to_non_object) (macro_error (/.:as boolean (: /.Boolean boolean))))) (_.cover [/.:as] (|> string diff --git a/stdlib/source/test/lux/ffi.old.lux b/stdlib/source/test/lux/ffi.old.lux index 9ca7d80b3..701828389 100644 --- a/stdlib/source/test/lux/ffi.old.lux +++ b/stdlib/source/test/lux/ffi.old.lux @@ -160,12 +160,12 @@ idx (|> random.nat (\ ! map (n.% size))) value random.int] ($_ _.and - (_.cover [/.array /.array_length] - (n.= size (/.array_length (/.array java/lang/Long size)))) - (_.cover [/.array_write /.array_read] + (_.cover [/.array /.length] + (n.= size (/.length (/.array java/lang/Long size)))) + (_.cover [/.write! /.read!] (|> (/.array java/lang/Long size) - (/.array_write idx value) - (/.array_read idx) + (/.write! idx value) + (/.read! idx) (i.= value))) ))) diff --git a/stdlib/source/test/lux/locale/language.lux b/stdlib/source/test/lux/locale/language.lux index 29389ae9f..e6ded5090 100644 --- a/stdlib/source/test/lux/locale/language.lux +++ b/stdlib/source/test/lux/locale/language.lux @@ -189,7 +189,7 @@ (List Bundle) [Nat (Set a)])) (list\fold (function (_ bundle [amount set]) - [(n.+ amount (get@ #amount bundle)) + [(n.+ amount (value@ #amount bundle)) (set.union set (lens bundle))]) [0 (set.empty hash)] territories)) @@ -198,11 +198,11 @@ Test (|> ..languages list.reversed - (list\map (get@ #test)) + (list\map (value@ #test)) (list\fold _.and (`` ($_ _.and (~~ (template [<lens> <tag> <hash>] - [(let [[amount set] (..aggregate (get@ <tag>) <hash> ..languages)] + [(let [[amount set] (..aggregate (value@ <tag>) <hash> ..languages)] (_.cover [<lens>] (n.= amount (set.size set))))] @@ -278,8 +278,8 @@ (def: .public random (Random /.Language) (let [options (|> ..languages - (list\map (|>> (get@ #languages) set.list)) - list.joined)] + (list\map (|>> (value@ #languages) set.list)) + list.together)] (do {! random.monad} [choice (\ ! map (n.% (list.size options)) random.nat)] diff --git a/stdlib/source/test/lux/locale/territory.lux b/stdlib/source/test/lux/locale/territory.lux index fa7aff326..d25308c49 100644 --- a/stdlib/source/test/lux/locale/territory.lux +++ b/stdlib/source/test/lux/locale/territory.lux @@ -144,7 +144,7 @@ (List Bundle) [Nat (Set a)])) (list\fold (function (_ bundle [amount set]) - [(n.+ amount (get@ #amount bundle)) + [(n.+ amount (value@ #amount bundle)) (set.union set (lens bundle))]) [0 (set.empty hash)] territories)) @@ -153,11 +153,11 @@ Test (|> ..territories list.reversed - (list\map (get@ #test)) + (list\map (value@ #test)) (list\fold _.and (`` ($_ _.and (~~ (template [<lens> <tag> <hash>] - [(let [[amount set] (..aggregate (get@ <tag>) <hash> ..territories)] + [(let [[amount set] (..aggregate (value@ <tag>) <hash> ..territories)] (_.cover [<lens>] (n.= amount (set.size set))))] @@ -204,8 +204,8 @@ (def: .public random (Random /.Territory) (let [options (|> ..territories - (list\map (|>> (get@ #territories) set.list)) - list.joined)] + (list\map (|>> (value@ #territories) set.list)) + list.together)] (do {! random.monad} [choice (\ ! map (n.% (list.size options)) random.nat)] diff --git a/stdlib/source/test/lux/macro/local.lux b/stdlib/source/test/lux/macro/local.lux index 1ab20df9a..c097f7676 100644 --- a/stdlib/source/test/lux/macro/local.lux +++ b/stdlib/source/test/lux/macro/local.lux @@ -52,9 +52,9 @@ [module short] (meta.normal name) _ (if pre_remove (let [remove_macro! (: (-> .Module .Module) - (update@ #.definitions (plist.lacks short)))] + (revised@ #.definitions (plist.lacks short)))] (function (_ lux) - (#try.Success [(update@ #.modules (plist.revised module remove_macro!) lux) + (#try.Success [(revised@ #.modules (plist.revised module remove_macro!) lux) []]))) (in []))] (let [pre_expansion (` (let [(~ g!output) (~ body)] diff --git a/stdlib/source/test/lux/macro/syntax/check.lux b/stdlib/source/test/lux/macro/syntax/check.lux index f9cbab99e..c2bfd9896 100644 --- a/stdlib/source/test/lux/macro/syntax/check.lux +++ b/stdlib/source/test/lux/macro/syntax/check.lux @@ -44,5 +44,5 @@ false (#try.Success check) - (and (code\= type (get@ #/.type check)) - (code\= value (get@ #/.value check))))))))) + (and (code\= type (value@ #/.type check)) + (code\= value (value@ #/.value check))))))))) diff --git a/stdlib/source/test/lux/macro/syntax/definition.lux b/stdlib/source/test/lux/macro/syntax/definition.lux index ae7d5d3e5..11074fbc7 100644 --- a/stdlib/source/test/lux/macro/syntax/definition.lux +++ b/stdlib/source/test/lux/macro/syntax/definition.lux @@ -76,7 +76,7 @@ (#try.Success actual) (\ /.equivalence = expected actual))) (_.cover [/.typed] - (let [expected (set@ #/.value (#.Left [type untyped_value]) expected)] + (let [expected (with@ #/.value (#.Left [type untyped_value]) expected)] (case (<code>.result (/.typed compiler) (list (/.format expected))) (#try.Failure error) @@ -85,7 +85,7 @@ (#try.Success actual) (\ /.equivalence = expected actual)))) (_.cover [/.lacks_type!] - (let [expected (set@ #/.value (#.Right untyped_value) expected)] + (let [expected (with@ #/.value (#.Right untyped_value) expected)] (case (<code>.result (/.typed compiler) (list (/.format expected))) (#try.Failure error) diff --git a/stdlib/source/test/lux/math.lux b/stdlib/source/test/lux/math.lux index f1bbc7fa6..8aeb528f5 100644 --- a/stdlib/source/test/lux/math.lux +++ b/stdlib/source/test/lux/math.lux @@ -92,7 +92,7 @@ (do {! random.monad} [.let [~= (f.approximately? ..margin_of_error)] sample (\ ! map (f.* +10.0) random.safe_frac) - power (\ ! map (|>> (n.% 10) inc n.frac) random.nat)] + power (\ ! map (|>> (n.% 10) ++ n.frac) random.nat)] ($_ _.and (_.cover [/.exp /.log] (|> sample /.exp /.log (f.approximately? +0.000000000000001 sample))) @@ -160,7 +160,7 @@ (~= (f.opposite tau/4) (/.atan/2 +0.0 (f.opposite (f.abs y)))) (f.not_a_number? (/.atan/2 +0.0 +0.0)))))) (do {! random.monad} - [of (\ ! map (|>> (n.% 10) inc) random.nat)] + [of (\ ! map (|>> (n.% 10) ++) random.nat)] (_.cover [/.factorial] (and (n.= 1 (/.factorial 0)) (|> (/.factorial of) (n.% of) (n.= 0))))) diff --git a/stdlib/source/test/lux/math/logic/continuous.lux b/stdlib/source/test/lux/math/logic/continuous.lux index a49e5c7d8..cd168fc4c 100644 --- a/stdlib/source/test/lux/math/logic/continuous.lux +++ b/stdlib/source/test/lux/math/logic/continuous.lux @@ -31,10 +31,10 @@ (_.cover [/.true /.false] (let [true=max! - (r.= /.false (inc /.true)) + (r.= /.false (++ /.true)) false=min! - (r.= /.true (dec /.false))] + (r.= /.true (-- /.false))] (and true=max! false=min!))) (_.cover [/.or] diff --git a/stdlib/source/test/lux/math/modulus.lux b/stdlib/source/test/lux/math/modulus.lux index f1e731975..ae3bbb8e1 100644 --- a/stdlib/source/test/lux/math/modulus.lux +++ b/stdlib/source/test/lux/math/modulus.lux @@ -63,6 +63,6 @@ (/.literal <divisor>)))) (_.cover [/.congruent?] (and (/.congruent? modulus dividend dividend) - (or (not (/.congruent? modulus dividend (inc dividend))) + (or (not (/.congruent? modulus dividend (++ dividend))) (i.= +1 (/.divisor modulus))))) )))) diff --git a/stdlib/source/test/lux/math/number/complex.lux b/stdlib/source/test/lux/math/number/complex.lux index 77cafc155..70706538d 100644 --- a/stdlib/source/test/lux/math/number/complex.lux +++ b/stdlib/source/test/lux/math/number/complex.lux @@ -43,8 +43,8 @@ (def: angle (Random /.Complex) (\ random.monad map - (|>> (update@ #/.real (f.% +1.0)) - (update@ #/.imaginary (f.% +1.0))) + (|>> (revised@ #/.real (f.% +1.0)) + (revised@ #/.imaginary (f.% +1.0))) ..random)) (def: construction @@ -55,11 +55,11 @@ ($_ _.and (_.cover [/.complex] (and (let [r+i (/.complex real imaginary)] - (and (f.= real (get@ #/.real r+i)) - (f.= imaginary (get@ #/.imaginary r+i)))) + (and (f.= real (value@ #/.real r+i)) + (f.= imaginary (value@ #/.imaginary r+i)))) (let [r+i (/.complex real)] - (and (f.= real (get@ #/.real r+i)) - (f.= +0.0 (get@ #/.imaginary r+i)))))) + (and (f.= real (value@ #/.real r+i)) + (f.= +0.0 (value@ #/.imaginary r+i)))))) (_.cover [/.approximately?] (/.approximately? ..margin_of_error (/.complex real imaginary) @@ -135,18 +135,18 @@ (_.cover [/.+] (let [z (/.+ y x)] (and (/.= z - (/.complex (f.+ (get@ #/.real y) - (get@ #/.real x)) - (f.+ (get@ #/.imaginary y) - (get@ #/.imaginary x))))))) + (/.complex (f.+ (value@ #/.real y) + (value@ #/.real x)) + (f.+ (value@ #/.imaginary y) + (value@ #/.imaginary x))))))) (_.cover [/.-] (let [normal! (let [z (/.- y x)] (and (/.= z - (/.complex (f.- (get@ #/.real y) - (get@ #/.real x)) - (f.- (get@ #/.imaginary y) - (get@ #/.imaginary x)))))) + (/.complex (f.- (value@ #/.real y) + (value@ #/.real x)) + (f.- (value@ #/.imaginary y) + (value@ #/.imaginary x)))))) inverse! (and (|> x (/.+ y) (/.- y) (/.approximately? ..margin_of_error x)) @@ -161,8 +161,8 @@ (let [rem (/.% y x) quotient (|> x (/.- rem) (/./ y)) floored (|> quotient - (update@ #/.real math.floor) - (update@ #/.imaginary math.floor))] + (revised@ #/.real math.floor) + (revised@ #/.imaginary math.floor))] (/.approximately? +0.000000000001 x (|> quotient (/.* y) (/.+ rem))))) @@ -175,10 +175,10 @@ ($_ _.and (_.cover [/.conjugate] (let [cx (/.conjugate x)] - (and (f.= (get@ #/.real x) - (get@ #/.real cx)) - (f.= (f.opposite (get@ #/.imaginary x)) - (get@ #/.imaginary cx))))) + (and (f.= (value@ #/.real x) + (value@ #/.real cx)) + (f.= (f.opposite (value@ #/.imaginary x)) + (value@ #/.imaginary cx))))) (_.cover [/.reciprocal] (let [reciprocal! (|> x (/.* (/.reciprocal x)) (/.approximately? ..margin_of_error /.+one)) diff --git a/stdlib/source/test/lux/math/number/i16.lux b/stdlib/source/test/lux/math/number/i16.lux index f82250048..807a58886 100644 --- a/stdlib/source/test/lux/math/number/i16.lux +++ b/stdlib/source/test/lux/math/number/i16.lux @@ -23,10 +23,10 @@ (<| (_.covering /._) (_.for [/.I16]) (do {! random.monad} - [.let [limit (|> (dec /.width) + [.let [limit (|> (-- /.width) //i64.mask .int - inc)] + ++)] expected (\ ! map (i.% limit) random.int)] ($_ _.and (_.for [/.equivalence] diff --git a/stdlib/source/test/lux/math/number/i32.lux b/stdlib/source/test/lux/math/number/i32.lux index a4c503bf7..06b2458e9 100644 --- a/stdlib/source/test/lux/math/number/i32.lux +++ b/stdlib/source/test/lux/math/number/i32.lux @@ -23,10 +23,10 @@ (<| (_.covering /._) (_.for [/.I32]) (do {! random.monad} - [.let [limit (|> (dec /.width) + [.let [limit (|> (-- /.width) //i64.mask .int - inc)] + ++)] expected (\ ! map (i.% limit) random.int)] ($_ _.and (_.for [/.equivalence] diff --git a/stdlib/source/test/lux/math/number/i64.lux b/stdlib/source/test/lux/math/number/i64.lux index d8e47745b..ac82addce 100644 --- a/stdlib/source/test/lux/math/number/i64.lux +++ b/stdlib/source/test/lux/math/number/i64.lux @@ -48,7 +48,7 @@ [pattern random.nat] ($_ _.and (do ! - [idx (\ ! map (|>> (n.% (dec /.width)) inc) random.nat)] + [idx (\ ! map (|>> (n.% (-- /.width)) ++) random.nat)] (_.cover [/.left_shifted /.right_shifted] (let [nullity! (and (\= pattern (/.left_shifted 0 pattern)) @@ -85,7 +85,7 @@ idempotency! (\= (/.and mask pattern) (/.and mask (/.and mask pattern))) - limit (inc (.nat mask)) + limit (++ (.nat mask)) limit! (if (n.< limit pattern) (\= pattern (/.and mask pattern)) (n.< limit (/.and mask pattern))) @@ -130,10 +130,10 @@ (#.Some sub) (do {! random.monad} - [.let [limit (|> (dec (\ sub width)) + [.let [limit (|> (-- (\ sub width)) /.mask .int - inc)] + ++)] expected (\ ! map (i.% limit) random.int) .let [random (: (All [size] (-> (-> I64 (I64 size)) (Random (I64 size)))) @@ -199,8 +199,8 @@ (_.cover [/.ones] (let [zero&one! (if (/.one? idx pattern) - (n.= (dec (/.ones pattern)) (/.ones (/.zero idx pattern))) - (n.= (inc (/.ones pattern)) (/.ones (/.one idx pattern)))) + (n.= (-- (/.ones pattern)) (/.ones (/.zero idx pattern))) + (n.= (++ (/.ones pattern)) (/.ones (/.one idx pattern)))) complementarity! (n.= /.width diff --git a/stdlib/source/test/lux/math/number/i8.lux b/stdlib/source/test/lux/math/number/i8.lux index 2764f93ec..7d753733d 100644 --- a/stdlib/source/test/lux/math/number/i8.lux +++ b/stdlib/source/test/lux/math/number/i8.lux @@ -23,10 +23,10 @@ (<| (_.covering /._) (_.for [/.I8]) (do {! random.monad} - [.let [limit (|> (dec /.width) + [.let [limit (|> (-- /.width) //i64.mask .int - inc)] + ++)] expected (\ ! map (i.% limit) random.int)] ($_ _.and (_.for [/.equivalence] diff --git a/stdlib/source/test/lux/math/number/int.lux b/stdlib/source/test/lux/math/number/int.lux index 6fba4351a..3c7cb47be 100644 --- a/stdlib/source/test/lux/math/number/int.lux +++ b/stdlib/source/test/lux/math/number/int.lux @@ -192,7 +192,7 @@ idempotency! (/.= pattern (/.right_shifted i64.width pattern)) - sign_mask (i64.left_shifted (dec i64.width) 1) + sign_mask (i64.left_shifted (-- i64.width) 1) mantissa_mask (i64.not sign_mask) sign_preservation! diff --git a/stdlib/source/test/lux/math/number/nat.lux b/stdlib/source/test/lux/math/number/nat.lux index d6e64603e..bf4a7eb40 100644 --- a/stdlib/source/test/lux/math/number/nat.lux +++ b/stdlib/source/test/lux/math/number/nat.lux @@ -104,7 +104,7 @@ (/.= rem (/.% left right))))) )) (do {! random.monad} - [.let [random (\ ! map (|>> (/.% 1,000) inc) random.nat)] + [.let [random (\ ! map (|>> (/.% 1,000) ++) random.nat)] left random right random] ($_ _.and diff --git a/stdlib/source/test/lux/math/number/rev.lux b/stdlib/source/test/lux/math/number/rev.lux index b0d857464..fdb68b72c 100644 --- a/stdlib/source/test/lux/math/number/rev.lux +++ b/stdlib/source/test/lux/math/number/rev.lux @@ -99,7 +99,7 @@ divisor/0 divisor divisor/1 (random.only (|>> (/.= divisor/0) not) divisor) - scale (\ ! map (|>> (n.% 10) inc) + scale (\ ! map (|>> (n.% 10) ++) random.nat)] ($_ _.and (_.cover [/./] diff --git a/stdlib/source/test/lux/meta.lux b/stdlib/source/test/lux/meta.lux index 5c84f9c38..a56457c9c 100644 --- a/stdlib/source/test/lux/meta.lux +++ b/stdlib/source/test/lux/meta.lux @@ -320,7 +320,7 @@ (/.result expected_lux) (!expect (^multi (#try.Success [actual_pre actual_post]) (and (n.= expected_seed actual_pre) - (n.= (inc expected_seed) actual_post)))))) + (n.= (++ expected_seed) actual_post)))))) (_.cover [/.location] (|> /.location (/.result expected_lux) diff --git a/stdlib/source/test/lux/target/jvm.lux b/stdlib/source/test/lux/target/jvm.lux index ae4685790..2a21207d4 100644 --- a/stdlib/source/test/lux/target/jvm.lux +++ b/stdlib/source/test/lux/target/jvm.lux @@ -1019,13 +1019,13 @@ random.nat)] dimensions size sizesH size - sizesT (random.list (dec dimensions) size) + sizesT (random.list (-- dimensions) size) .let [type (loop [dimensions dimensions type (: (Type Object) ..$Object)] (case dimensions 0 type - _ (recur (dec dimensions) (/type.array type))))]] + _ (recur (-- dimensions) (/type.array type))))]] (<| (_.lifted "MULTIANEWARRAY") (..bytecode (|>> (:as Nat) (n.= sizesH))) (do {! /.monad} @@ -1051,13 +1051,13 @@ (-> (Primitive a) (Primitive z) (Bytecode Any) (-> a z) (-> z Any Bit) (Random Bit))) (function (_ from to instruction convert test) (do random.monad - [input (get@ #random from) + [input (value@ #random from) .let [expected (convert input)]] (..bytecode (test expected) (do /.monad - [_ ((get@ #literal from) input) + [_ ((value@ #literal from) input) _ instruction] - (get@ #wrap to)))))) + (value@ #wrap to)))))) int::= (!::= java/lang/Integer "jvm ieq" "jvm int =") long::= (!::= java/lang/Long "jvm leq" "jvm long =") float::= (!::= java/lang/Float "jvm feq" "jvm float =") @@ -1321,10 +1321,10 @@ (do random.monad [class_name ..class_name primitive_method_name (random.ascii/upper 10) - .let [primitive_method_type (/type.method [(list) (list) (get@ #unboxed primitive) (list)])] + .let [primitive_method_type (/type.method [(list) (list) (value@ #unboxed primitive) (list)])] object_method_name (|> (random.ascii/upper 10) (random.only (|>> (text\= primitive_method_name) not))) - expected (get@ #random primitive) + expected (value@ #random primitive) .let [$Self (/type.class class_name (list))]] (in (case (do try.monad [class (/class.class /version.v6_0 /class.public @@ -1337,11 +1337,11 @@ primitive_method_type (list) (#.Some (do /.monad - [_ ((get@ #literal primitive) expected)] + [_ ((value@ #literal primitive) expected)] return))) (/method.method ..method_modifier object_method_name - (/type.method [(list) (list) (get@ #boxed primitive) (list)]) + (/type.method [(list) (list) (value@ #boxed primitive) (list)]) (list) (#.Some (do /.monad [_ (/.invokestatic $Self primitive_method_name primitive_method_type) @@ -1351,7 +1351,7 @@ (#.Some substitute) (substitute expected)) - _ (get@ #wrap primitive)] + _ (value@ #wrap primitive)] /.areturn)))) (row.row)) .let [bytecode (format.result /class.writer class) diff --git a/stdlib/source/test/lux/test.lux b/stdlib/source/test/lux/test.lux index eef7b91e7..e51623e28 100644 --- a/stdlib/source/test/lux/test.lux +++ b/stdlib/source/test/lux/test.lux @@ -25,8 +25,8 @@ (-> Text Text Nat Nat [/.Tally Text] Bit) (and (text.contains? expected_message/0 message) (text.contains? expected_message/1 message) - (n.= successes (get@ #/.successes tally)) - (n.= failures (get@ #/.failures tally)))) + (n.= successes (value@ #/.successes tally)) + (n.= failures (value@ #/.failures tally)))) (def: assertion /.Test @@ -41,10 +41,10 @@ (/.cover' [/.assertion /.Tally] (and (text.ends_with? expected_message/0 success_message) (text.ends_with? expected_message/0 failure_message) - (and (n.= 1 (get@ #/.successes success_tally)) - (n.= 0 (get@ #/.failures success_tally))) - (and (n.= 0 (get@ #/.successes failure_tally)) - (n.= 1 (get@ #/.failures failure_tally))))))) + (and (n.= 1 (value@ #/.successes success_tally)) + (n.= 0 (value@ #/.failures success_tally))) + (and (n.= 0 (value@ #/.successes failure_tally)) + (n.= 1 (value@ #/.failures failure_tally))))))) (in (do async.monad [tt (/.and' (/.assertion expected_message/0 true) (/.assertion expected_message/1 true)) @@ -82,10 +82,10 @@ [[pre_tally pre_message] pre [post_tally post_message] post] (/.cover' [/.seed] - (and (and (n.= 1 (get@ #/.successes pre_tally)) - (n.= 0 (get@ #/.failures pre_tally))) - (and (n.= 1 (get@ #/.successes post_tally)) - (n.= 0 (get@ #/.failures post_tally))))))))) + (and (and (n.= 1 (value@ #/.successes pre_tally)) + (n.= 0 (value@ #/.failures pre_tally))) + (and (n.= 1 (value@ #/.successes post_tally)) + (n.= 0 (value@ #/.failures post_tally))))))))) (def: times /.Test @@ -95,32 +95,32 @@ (in (do async.monad [[tally error] times_assertion] (/.cover' [/.must_try_test_at_least_once] - (and (text.contains? (get@ #exception.label /.must_try_test_at_least_once) error) - (n.= 0 (get@ #/.successes tally)) - (n.= 1 (get@ #/.failures tally))))))) + (and (text.contains? (value@ #exception.label /.must_try_test_at_least_once) error) + (n.= 0 (value@ #/.successes tally)) + (n.= 1 (value@ #/.failures tally))))))) (do {! random.monad} - [expected (\ ! map (|>> (n.% 10) inc) random.nat) + [expected (\ ! map (|>> (n.% 10) ++) random.nat) .let [counter (: (Atom Nat) (atom.atom 0))] times_assertion (<| (/.times expected) (do ! [_ (in []) - .let [_ (io.run! (atom.update! inc counter))]] + .let [_ (io.run! (atom.update! ++ counter))]] (/.test "" true)))] (in (do async.monad [[tally error] times_assertion actual (async.future (atom.read! counter))] (/.cover' [/.times] (and (n.= expected actual) - (n.= 1 (get@ #/.successes tally)) - (n.= 0 (get@ #/.failures tally))))))) + (n.= 1 (value@ #/.successes tally)) + (n.= 0 (value@ #/.failures tally))))))) )) (def: in_parallel /.Test ($_ /.and (do {! random.monad} - [expected (\ ! map (|>> (n.% 10) inc) random.nat) + [expected (\ ! map (|>> (n.% 10) ++) random.nat) .let [counter (: (Atom Nat) (atom.atom 0))] assertion (<| /.in_parallel @@ -128,17 +128,17 @@ (: /.Test) (do ! [_ (in []) - .let [_ (io.run! (atom.update! inc counter))]] + .let [_ (io.run! (atom.update! ++ counter))]] (/.test "" true)))] (in (do async.monad [[tally error] assertion actual (async.future (atom.read! counter))] (/.cover' [/.in_parallel] (and (n.= expected actual) - (n.= expected (get@ #/.successes tally)) - (n.= 0 (get@ #/.failures tally))))))) + (n.= expected (value@ #/.successes tally)) + (n.= 0 (value@ #/.failures tally))))))) (do {! random.monad} - [expected (\ ! map (|>> (n.% 10) inc) random.nat) + [expected (\ ! map (|>> (n.% 10) ++) random.nat) .let [counter (: (Atom Nat) (atom.atom 0))] assertion (<| /.in_parallel @@ -147,16 +147,16 @@ (do ! [_ (in []) .let [_ (undefined) - _ (io.run! (atom.update! inc counter))]] + _ (io.run! (atom.update! ++ counter))]] (/.test "" true)))] (in (do async.monad [[tally error] assertion actual (async.future (atom.read! counter))] (/.cover' [/.error_during_execution] - (let [correct_error! (text.contains? (get@ #exception.label /.error_during_execution) error) + (let [correct_error! (text.contains? (value@ #exception.label /.error_during_execution) error) no_complete_run! (n.= 0 actual) - no_successes! (n.= 0 (get@ #/.successes tally)) - ran_all_tests! (n.= expected (get@ #/.failures tally))] + no_successes! (n.= 0 (value@ #/.successes tally)) + ran_all_tests! (n.= expected (value@ #/.failures tally))] (and correct_error! no_complete_run! no_successes! @@ -176,10 +176,10 @@ [[not_covering _] not_covering [covering _] covering] (/.cover' [/.covering] - (and (and (set.empty? (get@ #/.expected_coverage not_covering)) - (set.empty? (get@ #/.actual_coverage not_covering))) - (and (not (set.empty? (get@ #/.expected_coverage covering))) - (set.empty? (get@ #/.actual_coverage covering)))))))) + (and (and (set.empty? (value@ #/.expected_coverage not_covering)) + (set.empty? (value@ #/.actual_coverage not_covering))) + (and (not (set.empty? (value@ #/.expected_coverage covering))) + (set.empty? (value@ #/.actual_coverage covering)))))))) (do random.monad [not_covering (/.covering .._ (/.test "" true)) covering (/.covering .._ (/.cover [..dummy_target] true))] @@ -187,10 +187,10 @@ [[not_covering _] not_covering [covering _] covering] (/.cover' [/.cover] - (and (and (not (set.empty? (get@ #/.expected_coverage not_covering))) - (not (set.member? (get@ #/.actual_coverage not_covering) (name_of ..dummy_target)))) - (and (not (set.empty? (get@ #/.expected_coverage covering))) - (set.member? (get@ #/.actual_coverage covering) (name_of ..dummy_target)))))))) + (and (and (not (set.empty? (value@ #/.expected_coverage not_covering))) + (not (set.member? (value@ #/.actual_coverage not_covering) (name_of ..dummy_target)))) + (and (not (set.empty? (value@ #/.expected_coverage covering))) + (set.member? (value@ #/.actual_coverage covering) (name_of ..dummy_target)))))))) (do random.monad [not_covering (/.covering .._ (/.test "" true)) covering (/.covering .._ (in (/.cover' [..dummy_target] true)))] @@ -198,10 +198,10 @@ [[not_covering _] not_covering [covering _] covering] (/.cover' [/.cover'] - (and (and (not (set.empty? (get@ #/.expected_coverage not_covering))) - (not (set.member? (get@ #/.actual_coverage not_covering) (name_of ..dummy_target)))) - (and (not (set.empty? (get@ #/.expected_coverage covering))) - (set.member? (get@ #/.actual_coverage covering) (name_of ..dummy_target)))))))) + (and (and (not (set.empty? (value@ #/.expected_coverage not_covering))) + (not (set.member? (value@ #/.actual_coverage not_covering) (name_of ..dummy_target)))) + (and (not (set.empty? (value@ #/.expected_coverage covering))) + (set.member? (value@ #/.actual_coverage covering) (name_of ..dummy_target)))))))) (do random.monad [not_covering (/.covering .._ (/.test "" true)) covering (/.covering .._ (/.for [..dummy_target] (/.test "" true)))] @@ -209,10 +209,10 @@ [[not_covering _] not_covering [covering _] covering] (/.cover' [/.for] - (and (and (not (set.empty? (get@ #/.expected_coverage not_covering))) - (not (set.member? (get@ #/.actual_coverage not_covering) (name_of ..dummy_target)))) - (and (not (set.empty? (get@ #/.expected_coverage covering))) - (set.member? (get@ #/.actual_coverage covering) (name_of ..dummy_target)))))))) + (and (and (not (set.empty? (value@ #/.expected_coverage not_covering))) + (not (set.member? (value@ #/.actual_coverage not_covering) (name_of ..dummy_target)))) + (and (not (set.empty? (value@ #/.expected_coverage covering))) + (set.member? (value@ #/.actual_coverage covering) (name_of ..dummy_target)))))))) )) (def: .public test @@ -239,10 +239,10 @@ (/.cover' [/.test] (and (text.ends_with? expected_message/0 success_message) (text.ends_with? expected_message/0 failure_message) - (and (n.= 1 (get@ #/.successes success_tally)) - (n.= 0 (get@ #/.failures success_tally))) - (and (n.= 0 (get@ #/.successes failure_tally)) - (n.= 1 (get@ #/.failures failure_tally)))))))) + (and (n.= 1 (value@ #/.successes success_tally)) + (n.= 0 (value@ #/.failures success_tally))) + (and (n.= 0 (value@ #/.successes failure_tally)) + (n.= 1 (value@ #/.failures failure_tally)))))))) (do ! [tt (/.and (/.test expected_message/0 true) (/.test expected_message/1 true)) @@ -273,18 +273,18 @@ (text.contains? expected_message/0 success_message)) (and (text.contains? expected_context failure_message) (text.contains? expected_message/0 failure_message)) - (and (n.= 1 (get@ #/.successes success_tally)) - (n.= 0 (get@ #/.failures success_tally))) - (and (n.= 0 (get@ #/.successes failure_tally)) - (n.= 1 (get@ #/.failures failure_tally)))))))) + (and (n.= 1 (value@ #/.successes success_tally)) + (n.= 0 (value@ #/.failures success_tally))) + (and (n.= 0 (value@ #/.successes failure_tally)) + (n.= 1 (value@ #/.failures failure_tally)))))))) (do ! [failure_assertion (/.failure expected_message/0)] (in (do async.monad [[failure_tally failure_message] failure_assertion] (/.cover' [/.failure] (and (text.contains? expected_message/0 failure_message) - (and (n.= 0 (get@ #/.successes failure_tally)) - (n.= 1 (get@ #/.failures failure_tally)))))))) + (and (n.= 0 (value@ #/.successes failure_tally)) + (n.= 1 (value@ #/.failures failure_tally)))))))) (do ! [success_assertion (/.lifted expected_message/0 (in true)) failure_assertion (/.lifted expected_message/0 (in false))] @@ -294,10 +294,10 @@ (/.cover' [/.lifted] (and (text.contains? expected_message/0 success_message) (text.contains? expected_message/0 failure_message) - (and (n.= 1 (get@ #/.successes success_tally)) - (n.= 0 (get@ #/.failures success_tally))) - (and (n.= 0 (get@ #/.successes failure_tally)) - (n.= 1 (get@ #/.failures failure_tally)))))))) + (and (n.= 1 (value@ #/.successes success_tally)) + (n.= 0 (value@ #/.failures success_tally))) + (and (n.= 0 (value@ #/.successes failure_tally)) + (n.= 1 (value@ #/.failures failure_tally)))))))) ..times ..in_parallel ..coverage diff --git a/stdlib/source/test/lux/time/date.lux b/stdlib/source/test/lux/time/date.lux index 872e7f2ce..70bb0a93e 100644 --- a/stdlib/source/test/lux/time/date.lux +++ b/stdlib/source/test/lux/time/date.lux @@ -77,7 +77,7 @@ (try\map (\ /.equivalence = expected)) (try.else false)))) (do {! random.monad} - [year (\ ! map (|>> (n.% 10,000) inc) + [year (\ ! map (|>> (n.% 10,000) ++) random.nat) month (\ ! map (|>> (n.% 10) (n.+ 13)) random.nat) diff --git a/stdlib/source/test/lux/time/month.lux b/stdlib/source/test/lux/time/month.lux index 18d56c088..77a0a9702 100644 --- a/stdlib/source/test/lux/time/month.lux +++ b/stdlib/source/test/lux/time/month.lux @@ -31,7 +31,7 @@ (Random /.Month) (let [december (/.number #/.December)] (|> random.nat - (\ random.monad map (|>> (n.% december) inc)) + (\ random.monad map (|>> (n.% december) ++)) (random.one (|>> /.by_number try.maybe))))) (def: .public test diff --git a/stdlib/source/test/lux/time/year.lux b/stdlib/source/test/lux/time/year.lux index 513b1b92d..b43fb99eb 100644 --- a/stdlib/source/test/lux/time/year.lux +++ b/stdlib/source/test/lux/time/year.lux @@ -91,7 +91,7 @@ (and (i.= +1 (/.leaps leap)) (i.= (.int (n./ /.leap /.century)) (/.leaps century)) - (i.= (inc (i.* +4 (dec (/.leaps century)))) + (i.= (++ (i.* +4 (-- (/.leaps century)))) (/.leaps era)))) )) ))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux index aa4443cdb..92acc8672 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux @@ -179,7 +179,7 @@ (_.test "Can analyse exhaustive pattern-matching." (|> (analyse_pm exhaustive_branchesC) _structure.check_succeeds)) - (let [non_exhaustive_branchesC (list.first (dec (list.size exhaustive_branchesC)) + (let [non_exhaustive_branchesC (list.first (-- (list.size exhaustive_branchesC)) exhaustive_branchesC)] (_.test "Will reject non-exhaustive pattern-matching." (|> (analyse_pm non_exhaustive_branchesC) @@ -188,7 +188,7 @@ [redundant_patterns (exhaustive_branches false variantTC inputC) redundancy_idx (|> r.nat (\ ! map (n.% (list.size redundant_patterns)))) .let [redundant_branchesC (<| (list!map (branch outputC)) - list.joined + list.together (list (list.first redundancy_idx redundant_patterns) (list (maybe.trusted (list.item redundancy_idx redundant_patterns))) (list.after redundancy_idx redundant_patterns)))]] @@ -199,10 +199,10 @@ [[heterogeneousT heterogeneousC] (r.only (|>> product.left (check.subsumes? outputT) not) _primitive.primitive) heterogeneous_idx (|> r.nat (\ ! map (n.% (list.size exhaustive_patterns)))) - .let [heterogeneous_branchesC (list.joined (list (list.first heterogeneous_idx exhaustive_branchesC) - (list (let [[_pattern _body] (maybe.trusted (list.item heterogeneous_idx exhaustive_branchesC))] - [_pattern heterogeneousC])) - (list.after (inc heterogeneous_idx) exhaustive_branchesC)))]] + .let [heterogeneous_branchesC (list.together (list (list.first heterogeneous_idx exhaustive_branchesC) + (list (let [[_pattern _body] (maybe.trusted (list.item heterogeneous_idx exhaustive_branchesC))] + [_pattern heterogeneousC])) + (list.after (++ heterogeneous_idx) exhaustive_branchesC)))]] (_.test "Will reject pattern-matching if the bodies of the branches do not all have the same type." (|> (analyse_pm heterogeneous_branchesC) _structure.check_fails))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux index 42b1e366c..b0feacead 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux @@ -92,12 +92,12 @@ partialT (type.function (list.after partial_args inputsT) outputT) varT (#.Parameter 1) polyT (<| (type.univ_q 1) - (type.function (list.joined (list (list.first var_idx inputsT) - (list varT) - (list.after (inc var_idx) inputsT)))) + (type.function (list.together (list (list.first var_idx inputsT) + (list varT) + (list.after (++ var_idx) inputsT)))) varT) poly_inputT (maybe.trusted (list.item var_idx inputsT)) - partial_poly_inputsT (list.after (inc var_idx) inputsT) + partial_poly_inputsT (list.after (++ var_idx) inputsT) partial_polyT1 (<| (type.function partial_poly_inputsT) poly_inputT) partial_polyT2 (<| (type.univ_q 1) @@ -116,8 +116,8 @@ (|> (/.apply _primitive.phase inputsC polyT dummy_function archive.empty (' [])) (check_apply poly_inputT full_args))) (_.test "Polymorphic partial application propagates found type-vars." - (|> (/.apply _primitive.phase (list.first (inc var_idx) inputsC) polyT dummy_function archive.empty (' [])) - (check_apply partial_polyT1 (inc var_idx)))) + (|> (/.apply _primitive.phase (list.first (++ var_idx) inputsC) polyT dummy_function archive.empty (' [])) + (check_apply partial_polyT1 (++ var_idx)))) (_.test "Polymorphic partial application preserves quantification for type-vars." (|> (/.apply _primitive.phase (list.first var_idx inputsC) polyT dummy_function archive.empty (' [])) (check_apply partial_polyT2 var_idx))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/structure.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/structure.lux index d27b85baf..1b8939368 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/structure.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/structure.lux @@ -1,6 +1,7 @@ (.module: [lux #* - [abstract ["." monad (#+ do)]] + [abstract + ["." monad (#+ do)]] [data ["%" text/format (#+ format)] ["." name]] @@ -54,12 +55,12 @@ (def: (check_sum' tag size variant) (-> Tag Nat (Variant Analysis) Bit) - (let [expected//right? (n.= (dec size) tag) + (let [expected//right? (n.= (-- size) tag) expected//lefts (if expected//right? - (dec tag) + (-- tag) tag) - actual//right? (get@ #////analysis.right? variant) - actual//lefts (get@ #////analysis.lefts variant)] + actual//right? (value@ #////analysis.right? variant) + actual//lefts (value@ #////analysis.lefts variant)] (and (n.= expected//lefts actual//lefts) (bit\= expected//right? @@ -121,14 +122,14 @@ [size (|> r.nat (\ ! map (|>> (n.% 10) (n.max 2)))) choice (|> r.nat (\ ! map (n.% size))) primitives (r.list size _primitive.primitive) - +choice (|> r.nat (\ ! map (n.% (inc size)))) + +choice (|> r.nat (\ ! map (n.% (++ size)))) [_ +valueC] _primitive.primitive .let [variantT (type.variant (list\map product.left primitives)) [valueT valueC] (maybe.trusted (list.item choice primitives)) - +size (inc size) - +primitives (list.joined (list (list.first choice primitives) - (list [(#.Parameter 1) +valueC]) - (list.after choice primitives))) + +size (++ size) + +primitives (list.together (list (list.first choice primitives) + (list [(#.Parameter 1) +valueC]) + (list.after choice primitives))) [+valueT +valueC] (maybe.trusted (list.item +choice +primitives)) +variantT (type.variant (list\map product.left +primitives))]] (<| (_.context (%.name (name_of /.sum))) @@ -176,9 +177,9 @@ [_ +valueC] _primitive.primitive .let [tupleT (type.tuple (list\map product.left primitives)) [singletonT singletonC] (|> primitives (list.item choice) maybe.trusted) - +primitives (list.joined (list (list.first choice primitives) - (list [(#.Parameter 1) +valueC]) - (list.after choice primitives))) + +primitives (list.together (list (list.first choice primitives) + (list [(#.Parameter 1) +valueC]) + (list.after choice primitives))) +tupleT (type.tuple (list\map product.left +primitives))]] (<| (_.context (%.name (name_of /.product))) ($_ _.and @@ -243,9 +244,9 @@ [choiceT choiceC] (maybe.trusted (list.item choice primitives)) [other_choiceT other_choiceC] (maybe.trusted (list.item other_choice primitives)) monoT (type.variant primitivesT) - polyT (|> (type.variant (list.joined (list (list.first choice primitivesT) - (list varT) - (list.after (inc choice) primitivesT)))) + polyT (|> (type.variant (list.together (list (list.first choice primitivesT) + (list varT) + (list.after (++ choice) primitivesT)))) (type.univ_q 1)) choice_tag (maybe.trusted (list.item choice tags)) other_choice_tag (maybe.trusted (list.item other_choice tags))]] @@ -288,9 +289,9 @@ primitivesC (list\map product.right primitives) monoT (#.Named [module_name type_name] (type.tuple primitivesT)) recordC (list.zipped/2 tagsC primitivesC) - polyT (|> (type.tuple (list.joined (list (list.first choice primitivesT) - (list varT) - (list.after (inc choice) primitivesT)))) + polyT (|> (type.tuple (list.together (list (list.first choice primitivesT) + (list varT) + (list.after (++ choice) primitivesT)))) (type.univ_q 1) (#.Named [module_name type_name]))]] (<| (_.context (%.name (name_of /.record))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux index 224349569..b634c0115 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux @@ -119,7 +119,7 @@ (def: random_path (Random (analysis.Tuple synthesis.Member)) (do {! random.monad} - [size_1 (|> random.nat (\ ! map (|>> (n.% 10) inc)))] + [size_1 (|> random.nat (\ ! map (|>> (n.% 10) ++)))] (random.list size_1 ..random_member))) (def: (get_pattern path) @@ -136,7 +136,7 @@ (#.Right lefts) (analysis.pattern/tuple - (list\compose (list.repeated (inc lefts) (analysis.pattern/unit)) + (list\compose (list.repeated (++ lefts) (analysis.pattern/unit)) (list inner))))) (#analysis.Bind @member) (list.reversed path)) @@ -290,7 +290,7 @@ branch (: (-> Nat Bit Text Frac Branch) (function (_ lefts right? value body) {#analysis.when (if right? - (analysis.pattern/tuple (list\compose (list.repeated (inc lefts) (analysis.pattern/unit)) + (analysis.pattern/tuple (list\compose (list.repeated (++ lefts) (analysis.pattern/unit)) (list (analysis.pattern/text value)))) (analysis.pattern/tuple ($_ list\compose (list.repeated lefts (analysis.pattern/unit)) @@ -299,7 +299,7 @@ #analysis.then (analysis.frac body)}))]] (in [(list\fold (function (_ left right) (#synthesis.Alt left right)) - (path (inc mid_size) true value/last body/last) + (path (++ mid_size) true value/last body/last) (|> (list.zipped/2 value/mid body/mid) (#.Item [value/first body/first]) list.enumeration @@ -310,8 +310,8 @@ (list\compose (|> (list.zipped/2 value/mid body/mid) list.enumeration (list\map (function (_ [lefts' [value body]]) - (branch (inc lefts') false value body)))) - (list (branch (inc mid_size) true value/last body/last)))]]))) + (branch (++ lefts') false value body)))) + (list (branch (++ mid_size) true value/last body/last)))]]))) (def: random_complex ($_ random.either diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux index 692a2fab9..a25bd787c 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux @@ -146,7 +146,7 @@ (def: (random_variable arity output?) (-> Arity Scenario) (do {! random.monad} - [register (\ ! map (|>> (n.% arity) inc) random.nat)] + [register (\ ! map (|>> (n.% arity) ++) random.nat)] (in [(not (n.= 0 register)) (synthesis.variable/local register) (if (n.= arity register) @@ -194,20 +194,20 @@ (synthesis.path/then expected_output)) (synthesis.path/seq (synthesis.path/text text_test) (synthesis.path/then expected_output)) - (synthesis.path/seq (synthesis.path/bind (inc arity)) + (synthesis.path/seq (synthesis.path/bind (++ arity)) (synthesis.path/then expected_output)) ($_ synthesis.path/seq (synthesis.path/side side|member) - (synthesis.path/bind (inc arity)) + (synthesis.path/bind (++ arity)) (synthesis.path/then expected_output)) (if right? ($_ synthesis.path/seq (synthesis.path/member side|member) - (synthesis.path/bind (inc arity)) + (synthesis.path/bind (++ arity)) (synthesis.path/then expected_output)) ($_ synthesis.path/seq (synthesis.path/member side|member) - (synthesis.path/bind (inc arity)) + (synthesis.path/bind (++ arity)) synthesis.path/pop (synthesis.path/then expected_output))))]) (#analysis.Case actual_input @@ -243,7 +243,7 @@ (in [(and loop?_input loop?_output) (synthesis.branch/let [expected_input - (inc arity) + (++ arity) expected_output]) (#analysis.Case actual_input [{#analysis.when (#analysis.Bind 2) @@ -323,7 +323,7 @@ true (list\map product.left resets)) (synthesis.loop/scope - {#synthesis.start (inc arity) + {#synthesis.start (++ arity) #synthesis.inits (list\map (|>> product.right product.left) resets) #synthesis.iteration expected_output}) (analysis.apply [(..n_abstraction arity actual_output) @@ -342,7 +342,7 @@ Scenario (do {! random.monad} [[loop?_output expected_output actual_output] (..random_nat output?) - arity (|> random.nat (\ ! map (|>> (n.% 5) inc))) + arity (|> random.nat (\ ! map (|>> (n.% 5) ++))) .let [environment ($_ list\compose (list\map (|>> #variable.Foreign) (list.indices arity)) @@ -362,7 +362,7 @@ (-> Scenario Scenario) (do {! random.monad} [[loop?_abstraction expected_abstraction actual_abstraction] (..random_nat output?) - arity (|> random.nat (\ ! map (|>> (n.% 5) inc))) + arity (|> random.nat (\ ! map (|>> (n.% 5) ++))) inputs (random.list arity (random_value false))] (in [(list\fold (function (_ new old) (and new old)) @@ -418,7 +418,7 @@ (def: random_abstraction (Random [Synthesis Analysis]) (do {! random.monad} - [arity (|> random.nat (\ ! map (|>> (n.% 5) inc))) + [arity (|> random.nat (\ ! map (|>> (n.% 5) ++))) [loop? expected_body actual_body] (random_body arity true)] (in [(..n_function loop? arity expected_body) (..n_abstraction arity actual_body)]))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/loop.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/loop.lux index 9aa7bdfe9..41dff47e9 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/loop.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/loop.lux @@ -55,7 +55,7 @@ (def: (variable offset arity next) (Scenario Variable) (let [local (do {! random.monad} - [register (\ ! map (|>> (n.% arity) inc) random.nat)] + [register (\ ! map (|>> (n.% arity) ++) random.nat)] (in [next [(#variable.Local (/.register_optimization offset register)) (#variable.Local register)]]))] @@ -139,7 +139,7 @@ [//.path/side] [//.path/member] )) - (random\in [(inc next) + (random\in [(++ next) [(//.path/bind (/.register_optimization offset next)) (//.path/bind next)]]) )))) @@ -182,7 +182,7 @@ ($_ random.either (do {! random.monad} [[next [recordE recordA]] (..reference offset arity next) - path_length (\ ! map (|>> (n.% 5) inc) random.nat) + path_length (\ ! map (|>> (n.% 5) ++) random.nat) path (random.list path_length random_member)] (in [next [(//.branch/get [path recordE]) @@ -267,7 +267,7 @@ ($_ _.and (do {! random.monad} [expected_offset (\ ! map (|>> (n.% 5) (n.+ 2)) random.nat) - arity (\ ! map (|>> (n.% 5) inc) random.nat) + arity (\ ! map (|>> (n.% 5) ++) random.nat) expected_inits (|> random.nat (\ ! map (|>> .i64 //.i64)) (random.list arity)) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux index a7fa786fb..014a77ac2 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux @@ -1,6 +1,7 @@ (.module: [lux #* - [abstract ["." monad (#+ do)]] + [abstract + ["." monad (#+ do)]] [data ["%" text/format (#+ format)] ["." name]] @@ -37,9 +38,9 @@ (do {! r.monad} [size (|> r.nat (\ ! map (|>> (n.% 10) (n.+ 2)))) tagA (|> r.nat (\ ! map (n.% size))) - .let [right? (n.= (dec size) tagA) + .let [right? (n.= (-- size) tagA) lefts (if right? - (dec tagA) + (-- tagA) tagA)] memberA //primitive.primitive] (_.test "Can synthesize variants." @@ -47,9 +48,9 @@ (//.phase archive.empty) (phase.result [///bundle.empty ////synthesis.init]) (case> (^ (#try.Success (////synthesis.variant [leftsS right?S valueS]))) - (let [tagS (if right?S (inc leftsS) leftsS)] + (let [tagS (if right?S (++ leftsS) leftsS)] (and (n.= tagA tagS) - (|> tagS (n.= (dec size)) (bit\= right?S)) + (|> tagS (n.= (-- size)) (bit\= right?S)) (//primitive.corresponds? memberA valueS))) _ diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux index 2678f8f77..10a6ca270 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux @@ -70,9 +70,9 @@ (do ! [let? random.bit [expected_input actual_input] (..primitive_scenario context) - .let [fake_register (n.+ (get@ #redundants context) - (dictionary.size (get@ #necessary context)))] - [expected_output actual_output] (scenario (update@ #redundants inc context))] + .let [fake_register (n.+ (value@ #redundants context) + (dictionary.size (value@ #necessary context)))] + [expected_output actual_output] (scenario (revised@ #redundants ++ context))] (in [(synthesis.branch/case [expected_input (#synthesis.Seq #synthesis.Pop (#synthesis.Then expected_output))]) @@ -95,7 +95,7 @@ (def: (tuple_scenario context) (Scenario Synthesis) - (let [registers (dictionary.entries (get@ #necessary context))] + (let [registers (dictionary.entries (value@ #necessary context))] (\ random.monad in [(synthesis.tuple (list\map (|>> product.left synthesis.variable/local) registers)) (synthesis.tuple (list\map (|>> product.right synthesis.variable/local) registers))]))) @@ -110,10 +110,10 @@ (do random.monad [_ (in []) [expected_input actual_input] (scenario context) - .let [real_register (dictionary.size (get@ #necessary context)) - fake_register (n.+ (get@ #redundants context) - (dictionary.size (get@ #necessary context)))] - [expected_output actual_output] (scenario (update@ #necessary (dictionary.has real_register fake_register) context))] + .let [real_register (dictionary.size (value@ #necessary context)) + fake_register (n.+ (value@ #redundants context) + (dictionary.size (value@ #necessary context)))] + [expected_output actual_output] (scenario (revised@ #necessary (dictionary.has real_register fake_register) context))] (in [(synthesis.branch/let [expected_input real_register expected_output]) (synthesis.branch/let [actual_input fake_register actual_output])]))) @@ -143,7 +143,7 @@ (def: (get_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} - [length (\ ! map (|>> (n.% 5) inc) random.nat) + [length (\ ! map (|>> (n.% 5) ++) random.nat) path (random.list length ..random_member) [expected_record actual_record] (scenario context)] (in [(synthesis.branch/get [path expected_record]) @@ -166,10 +166,10 @@ (#synthesis.Then actual_then))])) (do {! random.monad} [_ (in []) - .let [real_register (dictionary.size (get@ #necessary context)) - fake_register (n.+ (get@ #redundants context) - (dictionary.size (get@ #necessary context)))] - [expected_then actual_then] (scenario (update@ #necessary (dictionary.has real_register fake_register) context))] + .let [real_register (dictionary.size (value@ #necessary context)) + fake_register (n.+ (value@ #redundants context) + (dictionary.size (value@ #necessary context)))] + [expected_then actual_then] (scenario (revised@ #necessary (dictionary.has real_register fake_register) context))] (in [(#synthesis.Seq (#synthesis.Bind real_register) (#synthesis.Seq #synthesis.Pop (#synthesis.Then expected_then))) @@ -238,19 +238,19 @@ (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [_ (in []) - .let [real_start (dictionary.size (get@ #necessary context)) - fake_start (n.+ (get@ #redundants context) + .let [real_start (dictionary.size (value@ #necessary context)) + fake_start (n.+ (value@ #redundants context) real_start)] inits (random.list ..scope_arity (scenario context)) - [expected_iteration actual_iteration] (scenario (update@ #necessary - (function (_ necessary) - (list\fold (function (_ [idx _] context) - (dictionary.has (n.+ real_start idx) - (n.+ fake_start idx) - context)) - necessary - (list.enumeration inits))) - context))] + [expected_iteration actual_iteration] (scenario (revised@ #necessary + (function (_ necessary) + (list\fold (function (_ [idx _] context) + (dictionary.has (n.+ real_start idx) + (n.+ fake_start idx) + context)) + necessary + (list.enumeration inits))) + context))] (in [(synthesis.loop/scope [real_start (list\map product.left inits) expected_iteration]) (synthesis.loop/scope [fake_start (list\map product.right inits) actual_iteration])]))) @@ -273,7 +273,7 @@ (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [_ (in []) - .let [registers (dictionary.entries (get@ #necessary context)) + .let [registers (dictionary.entries (value@ #necessary context)) expected_environment (list\map (|>> product.left #variable.Local) registers) actual_environment (list\map (|>> product.right #variable.Local) registers)] [expected_body actual_body] (..primitive_scenario context)] diff --git a/stdlib/source/test/lux/type.lux b/stdlib/source/test/lux/type.lux index 8c135b590..65920eca9 100644 --- a/stdlib/source/test/lux/type.lux +++ b/stdlib/source/test/lux/type.lux @@ -45,27 +45,32 @@ (Random Name) (random.and ..short ..short)) -(def: .public (random parameters) +(def: (random' parameters) (-> Nat (Random Type)) (random.rec (function (_ recur) (let [pairG (random.and recur recur) - quantifiedG (random.and (random\in (list)) recur) un_parameterized (: (Random Type) ($_ random.either - (random\map (|>> #.Primitive) (random.and ..short (random\in (list)))) + (random\map (|>> #.Primitive) (random.and ..short (random.list 0 recur))) + (random\map (|>> #.Primitive) (random.and ..short (random.list 1 recur))) + (random\map (|>> #.Primitive) (random.and ..short (random.list 2 recur))) (random\map (|>> #.Sum) pairG) (random\map (|>> #.Product) pairG) (random\map (|>> #.Function) pairG) - (random\map (|>> #.UnivQ) quantifiedG) - (random\map (|>> #.ExQ) quantifiedG) - (random\map (|>> #.Apply) pairG) - (random\map (|>> #.Named) (random.and ..name recur)) ))] (case parameters 0 un_parameterized - _ (random.either un_parameterized - (random\map (|>> (n.% parameters) #.Parameter) random.nat))))))) + _ (|> random.nat + (random\map (|>> (n.% parameters) #.Parameter)) + (random.either un_parameterized))))))) + +(def: .public (random parameters) + (-> Nat (Random Type)) + ($_ random.either + (random\map (/.univ_q parameters) (random' parameters)) + (random\map (/.ex_q parameters) (random' parameters)) + )) (def: .public test Test @@ -98,7 +103,7 @@ _ #1))) (list.repeated size) - (monad.seq !)) + (monad.all !)) .let [(^open "/\.") /.equivalence (^open "list\.") (list.equivalence /.equivalence)]] (`` ($_ _.and @@ -123,7 +128,7 @@ (case> #.None #1 _ #0)))) (do {! random.monad} [size (|> random.nat (\ ! map (n.% 3))) - members (monad.seq ! (list.repeated size (..random 0))) + members (monad.all ! (list.repeated size (..random 0))) extra (|> (..random 0) (random.only (function (_ type) (case type @@ -144,7 +149,7 @@ (n.= (list.size members) (list.size tparams)))) )) (do {! random.monad} - [size (|> random.nat (\ ! map (|>> (n.% 3) inc))) + [size (|> random.nat (\ ! map (|>> (n.% 3) ++))) body_type (|> (..random 0) (random.only (function (_ type) (case type @@ -170,7 +175,7 @@ (|> body_type (/.ex_q size) /.quantified?))) ))) (do {! random.monad} - [depth (|> random.nat (\ ! map (|>> (n.% 3) inc))) + [depth (|> random.nat (\ ! map (|>> (n.% 3) ++))) element_type (|> (..random 0) (random.only (function (_ type) (case type diff --git a/stdlib/source/test/lux/type/abstract.lux b/stdlib/source/test/lux/type/abstract.lux index 6275647d0..f8fe3c6a3 100644 --- a/stdlib/source/test/lux/type/abstract.lux +++ b/stdlib/source/test/lux/type/abstract.lux @@ -28,7 +28,7 @@ [(syntax: (<syntax> []) (do meta.monad [frame <meta>] - (in (list (code.text (get@ #/.name frame))))))] + (in (list (code.text (value@ #/.name frame))))))] [current /.current] [specific (/.specific (template.text [g!Foo]))] diff --git a/stdlib/source/test/lux/type/check.lux b/stdlib/source/test/lux/type/check.lux index 1875d4fc8..d148e9fdc 100644 --- a/stdlib/source/test/lux/type/check.lux +++ b/stdlib/source/test/lux/type/check.lux @@ -43,7 +43,7 @@ (random.rec (function (_ recur) (let [pairG (random.and recur recur) - quantifiedG (random.and (random\in (list)) (type' (inc num_vars))) + quantifiedG (random.and (random\in (list)) (type' (++ num_vars))) random_pair (random.either (random.either (random\map (|>> #.Sum) pairG) (random\map (|>> #.Product) pairG)) (random.either (random\map (|>> #.Function) pairG) @@ -52,7 +52,7 @@ (random\map (|>> #.Ex) random.nat))] (case num_vars 0 random_id - _ (random.either (random\map (|>> (n.% num_vars) (n.* 2) inc #.Parameter) random.nat) + _ (random.either (random\map (|>> (n.% num_vars) (n.* 2) ++ #.Parameter) random.nat) random_id))) random_quantified (random.either (random\map (|>> #.UnivQ) quantifiedG) (random\map (|>> #.ExQ) quantifiedG))] @@ -220,10 +220,10 @@ (do random.monad [nominal (random.ascii/upper 10) .let [expected (#.Primitive nominal (list))]] - (_.cover [/.read] + (_.cover [/.read'] (and (|> (do /.monad [[var_id var_type] /.var] - (/.read var_id)) + (/.read' var_id)) (/.result /.fresh_context) (case> (#try.Success #.None) true _ false)) @@ -231,14 +231,14 @@ [[var_id var/0] /.var [_ var/1] /.var _ (/.check var/0 var/1)] - (/.read var_id)) + (/.read' var_id)) (/.result /.fresh_context) (case> (#try.Success #.None) true _ false)) (|> (do /.monad [[var_id var_type] /.var _ (/.bind expected var_id)] - (/.read var_id)) + (/.read' var_id)) (/.result /.fresh_context) (case> (#try.Success (#.Some actual)) (same? expected actual) @@ -248,12 +248,12 @@ (do random.monad [nominal (random.ascii/upper 10) .let [expected (#.Primitive nominal (list))]] - (_.cover [/.read!] + (_.cover [/.read] (case (/.result /.fresh_context (do /.monad [[var_id var_type] /.var _ (/.bind expected var_id)] - (/.read! var_id))) + (/.read var_id))) (#try.Success actual) (same? expected actual) @@ -266,7 +266,7 @@ (case (/.result /.fresh_context (do /.monad [[var_id var_type] /.var] - (/.read! var_id))) + (/.read var_id))) (#try.Failure error) (exception.match? /.unbound_type_var error) @@ -278,9 +278,9 @@ Test ($_ _.and (_.cover [/.fresh_context] - (and (n.= 0 (get@ #.var_counter /.fresh_context)) - (n.= 0 (get@ #.ex_counter /.fresh_context)) - (list.empty? (get@ #.var_bindings /.fresh_context)))) + (and (n.= 0 (value@ #.var_counter /.fresh_context)) + (n.= 0 (value@ #.ex_counter /.fresh_context)) + (list.empty? (value@ #.var_bindings /.fresh_context)))) (_.cover [/.context] (and (case (/.result /.fresh_context /.context) (#try.Success actual) @@ -293,9 +293,9 @@ [_ /.var] /.context)) (#try.Success actual) - (and (n.= 1 (get@ #.var_counter actual)) - (n.= 0 (get@ #.ex_counter actual)) - (n.= 1 (list.size (get@ #.var_bindings actual)))) + (and (n.= 1 (value@ #.var_counter actual)) + (n.= 0 (value@ #.ex_counter actual)) + (n.= 1 (list.size (value@ #.var_bindings actual)))) (#try.Failure error) false))) @@ -305,9 +305,9 @@ [_ /.existential] /.context)) (#try.Success actual) - (and (n.= 0 (get@ #.var_counter actual)) - (n.= 1 (get@ #.ex_counter actual)) - (n.= 0 (list.size (get@ #.var_bindings actual)))) + (and (n.= 0 (value@ #.var_counter actual)) + (n.= 1 (value@ #.ex_counter actual)) + (n.= 0 (list.size (value@ #.var_bindings actual)))) (#try.Failure error) false)) @@ -703,7 +703,7 @@ (-> Nat (Random Type)) (do random.monad [primitive (random.ascii/upper 3) - parameters (random.list parameters (primitive_type (dec parameters)))] + parameters (random.list parameters (primitive_type (-- parameters)))] (in (#.Primitive primitive parameters)))) (def: clean_type diff --git a/stdlib/source/test/lux/type/implicit.lux b/stdlib/source/test/lux/type/implicit.lux index d032f19c5..f50bd57e7 100644 --- a/stdlib/source/test/lux/type/implicit.lux +++ b/stdlib/source/test/lux/type/implicit.lux @@ -39,8 +39,8 @@ (let [(^open "list\.") (list.equivalence n.equivalence)] (and (bit\= (\ n.equivalence = left right) (/.\\ = left right)) - (list\= (\ list.functor map inc (enum.range n.enum start end)) - (/.\\ map inc (enum.range n.enum start end))))) + (list\= (\ list.functor map ++ (enum.range n.enum start end)) + (/.\\ map ++ (enum.range n.enum start end))))) second_order! (/.\\ = diff --git a/stdlib/source/test/lux/type/refinement.lux b/stdlib/source/test/lux/type/refinement.lux index cf69e9243..5942e2a84 100644 --- a/stdlib/source/test/lux/type/refinement.lux +++ b/stdlib/source/test/lux/type/refinement.lux @@ -32,7 +32,7 @@ modulus (\ ! map (|>> (n.% 10) (n.+ 2)) random.nat) .let [predicate (: (Predicate Nat) (|>> (n.% modulus) (n.= 0)))] - total_raws (\ ! map (|>> (n.% 20) inc) random.nat) + total_raws (\ ! map (|>> (n.% 20) ++) random.nat) raws (random.list total_raws random.nat)] ($_ _.and (_.for [/.Refiner] @@ -60,9 +60,9 @@ (maybe\map (|>> /.value (n.= (n.+ modulus modulus)))) (maybe.else false)) (|> (/.refiner predicate modulus) - (maybe\map (/.lifted (n.+ (inc modulus)))) + (maybe\map (/.lifted (n.+ (++ modulus)))) maybe\join - (maybe\map (|>> /.value (n.= (n.+ modulus (inc modulus))))) + (maybe\map (|>> /.value (n.= (n.+ modulus (++ modulus))))) (maybe.else false) not))) (_.cover [/.only] diff --git a/stdlib/source/test/lux/world/file/watch.lux b/stdlib/source/test/lux/world/file/watch.lux index 0bbff685f..0e7369716 100644 --- a/stdlib/source/test/lux/world/file/watch.lux +++ b/stdlib/source/test/lux/world/file/watch.lux @@ -118,7 +118,7 @@ (def: (after_modification! fs watcher data expected_path) (-> (//.System Async) (/.Watcher Async) Binary //.Path (Async (Try Bit))) (do (try.with async.monad) - [_ (async.delayed 1 (#try.Success "Delay to make sure the over_write time-stamp always changes.")) + [_ (async.after 1 (#try.Success "Delay to make sure the over_write time-stamp always changes.")) _ (\ fs write data expected_path) poll/2 (\ watcher poll []) poll/2' (\ watcher poll [])] diff --git a/stdlib/source/test/lux/world/input/keyboard.lux b/stdlib/source/test/lux/world/input/keyboard.lux index 67ce892fe..865a66a9d 100644 --- a/stdlib/source/test/lux/world/input/keyboard.lux +++ b/stdlib/source/test/lux/world/input/keyboard.lux @@ -112,13 +112,13 @@ /.f24]])] (def: listing (List /.Key) - (list.joined (`` (list (~~ (template [<definition> <keys>] - [((: (-> Any (List /.Key)) - (function (_ _) - (`` (list (~~ (template.spliced <keys>)))))) - [])] - - <groups>)))))) + (list.together (`` (list (~~ (template [<definition> <keys>] + [((: (-> Any (List /.Key)) + (function (_ _) + (`` (list (~~ (template.spliced <keys>)))))) + [])] + + <groups>)))))) (def: catalogue (Set /.Key) @@ -160,8 +160,8 @@ [key ..random .let [sample (<function> key)]] (_.cover [<function>] - (and (bit\= <pressed?> (get@ #/.pressed? sample)) - (n.= key (get@ #/.input sample)))))] + (and (bit\= <pressed?> (value@ #/.pressed? sample)) + (n.= key (value@ #/.input sample)))))] [#0 /.release] [#1 /.press] diff --git a/stdlib/source/test/lux/world/net/http/client.lux b/stdlib/source/test/lux/world/net/http/client.lux index 24ece9d1e..c9b3f12c9 100644 --- a/stdlib/source/test/lux/world/net/http/client.lux +++ b/stdlib/source/test/lux/world/net/http/client.lux @@ -70,7 +70,7 @@ (|> (<definition> "" //.empty #.None mock) (do> try.monad [io.run!] - [product.right (get@ #//.body) (function.apply #.None) io.run!] + [product.right (value@ #//.body) (function.on #.None) io.run!] [product.right (\ utf8.codec decode)] [(\ nat.decimal decode)] [(nat.= <expected>) in]) diff --git a/stdlib/source/test/lux/world/net/http/status.lux b/stdlib/source/test/lux/world/net/http/status.lux index 84cbd6355..c93f5b083 100644 --- a/stdlib/source/test/lux/world/net/http/status.lux +++ b/stdlib/source/test/lux/world/net/http/status.lux @@ -84,13 +84,13 @@ /.network_authentication_required]])] (def: all (List //.Status) - (list.joined (`` (list (~~ (template [<category> <status+>] - [((: (-> Any (List //.Status)) - (function (_ _) - (`` (list (~~ (template.spliced <status+>)))))) - 123)] - - <categories>)))))) + (list.together (`` (list (~~ (template [<category> <status+>] + [((: (-> Any (List //.Status)) + (function (_ _) + (`` (list (~~ (template.spliced <status+>)))))) + 123)] + + <categories>)))))) (def: unique (Set //.Status) diff --git a/stdlib/source/test/lux/world/program.lux b/stdlib/source/test/lux/world/program.lux index 879d1f60f..6f5784daf 100644 --- a/stdlib/source/test/lux/world/program.lux +++ b/stdlib/source/test/lux/world/program.lux @@ -42,7 +42,7 @@ Test (<| (_.covering /._) (do {! random.monad} - [env_size (\ ! map (|>> (n.% 10) inc) random.nat) + [env_size (\ ! map (|>> (n.% 10) ++) random.nat) environment (..environment env_size) home ..path directory ..path |