From 44cff1dcbd6cd23ef455923b707104302dde1aad Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Wed, 23 Nov 2022 20:35:07 -0400 Subject: New arithmetic abstraction + common file extensions as constants. --- .../library/lux/data/collection/sequence.lux | 148 ++++++++++---- stdlib/source/library/lux/data/format/tar.lux | 31 ++- stdlib/source/library/lux/math/arithmetic.lux | 22 +++ stdlib/source/library/lux/math/number/complex.lux | 103 +++++++--- stdlib/source/library/lux/math/number/frac.lux | 175 +++++++++++------ stdlib/source/library/lux/math/number/int.lux | 70 +++++-- stdlib/source/library/lux/math/number/nat.lux | 91 ++++++--- stdlib/source/library/lux/math/number/ratio.lux | 55 ++++-- stdlib/source/library/lux/math/number/rev.lux | 106 +++++++--- .../library/lux/meta/compiler/default/platform.lux | 2 +- .../lux/phase/extension/declaration/lux.lux | 48 ----- .../lux/meta/compiler/language/lux/translation.lux | 4 - .../compiler/meta/archive/artifact/category.lux | 17 +- .../lux/meta/compiler/meta/archive/registry.lux | 20 +- .../library/lux/meta/compiler/meta/io/archive.lux | 218 ++++++--------------- stdlib/source/library/lux/world/file/extension.lux | 108 ++++++++++ stdlib/source/specification/lux/abstract/order.lux | 93 +++++---- .../source/specification/lux/math/arithmetic.lux | 46 +++++ stdlib/source/test/lux/math/number/complex.lux | 6 +- stdlib/source/test/lux/math/number/frac.lux | 6 +- stdlib/source/test/lux/math/number/int.lux | 6 +- stdlib/source/test/lux/math/number/nat.lux | 6 +- stdlib/source/test/lux/math/number/ratio.lux | 6 +- stdlib/source/test/lux/math/number/rev.lux | 6 +- stdlib/source/test/lux/world/file.lux | 4 +- stdlib/source/test/lux/world/file/extension.lux | 148 ++++++++++++++ 26 files changed, 1037 insertions(+), 508 deletions(-) create mode 100644 stdlib/source/library/lux/math/arithmetic.lux create mode 100644 stdlib/source/library/lux/world/file/extension.lux create mode 100644 stdlib/source/specification/lux/math/arithmetic.lux create mode 100644 stdlib/source/test/lux/world/file/extension.lux (limited to 'stdlib/source') diff --git a/stdlib/source/library/lux/data/collection/sequence.lux b/stdlib/source/library/lux/data/collection/sequence.lux index c015edb06..86558bbb1 100644 --- a/stdlib/source/library/lux/data/collection/sequence.lux +++ b/stdlib/source/library/lux/data/collection/sequence.lux @@ -3,7 +3,7 @@ ... https://hypirion.com/musings/understanding-persistent-vector-pt-3 (.require [library - [lux (.except list has revised only) + [lux (.except list has revised only all) [abstract [functor (.only Functor)] [apply (.only Apply)] @@ -63,7 +63,8 @@ (with_template [ ] [(def - (-> Level Level) + (-> Level + Level) ( branching_exponent))] [level_up n.+] @@ -79,15 +80,19 @@ (-- full_node_size)) (def branch_idx - (-> Index Index) + (-> Index + Index) (i64.and branch_idx_mask)) (def (empty_hierarchy _) - (All (_ a) (-> Any (Hierarchy a))) + (All (_ of) + (-> Any + (Hierarchy of))) (array.empty ..full_node_size)) (def (tail_off sequence_size) - (-> Nat Nat) + (-> Nat + Nat) (if (n.< full_node_size sequence_size) 0 (|> (-- sequence_size) @@ -95,7 +100,9 @@ (i64.left_shifted branching_exponent)))) (def (path level tail) - (All (_ a) (-> Level (Base a) (Node a))) + (All (_ of) + (-> Level (Base of) + (Node of))) (if (n.= 0 level) {#Base tail} (|> (empty_hierarchy []) @@ -103,12 +110,16 @@ {#Hierarchy}))) (def (tail singleton) - (All (_ a) (-> a (Base a))) + (All (_ of) + (-> of + (Base of))) (|> (array.empty 1) (array.has! 0 singleton))) (def (with_tail size level tail parent) - (All (_ a) (-> Nat Level (Base a) (Hierarchy a) (Hierarchy a))) + (All (_ of) + (-> Nat Level (Base of) (Hierarchy of) + (Hierarchy of))) (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) @@ -129,14 +140,18 @@ (array.has! sub_idx sub_node)))) (def (expanded_tail val tail) - (All (_ a) (-> a (Base a) (Base a))) + (All (_ of) + (-> of (Base of) + (Base of))) (let [tail_size (array.size tail)] (|> (array.empty (++ tail_size)) (array.copy! tail_size 0 tail 0) (array.has! tail_size val)))) (def (hierarchy#has level idx val hierarchy) - (All (_ a) (-> Level Index a (Hierarchy a) (Hierarchy a))) + (All (_ of) + (-> Level Index of (Hierarchy of) + (Hierarchy of))) (let [sub_idx (branch_idx (i64.right_shifted level idx))] (when (array.item sub_idx hierarchy) {#Hierarchy sub_node} @@ -154,7 +169,9 @@ (undefined)))) (def (without_tail size level hierarchy) - (All (_ a) (-> Nat Level (Hierarchy a) (Maybe (Hierarchy a)))) + (All (_ of) + (-> Nat Level (Hierarchy of) + (Maybe (Hierarchy of)))) (let [sub_idx (branch_idx (i64.right_shifted level (n.- 2 size)))] (cond (n.= 0 sub_idx) {.#None} @@ -179,7 +196,9 @@ ))) (def (node#list node) - (All (_ a) (-> (Node a) (List a))) + (All (_ of) + (-> (Node of) + (List of))) (when node {#Base base} (array.list {.#None} base) @@ -192,12 +211,12 @@ (list#composite (node#list sub) acc)) {.#End})))) -(type .public (Sequence a) +(type .public (Sequence of) (Record [#level Level #size Nat - #root (Hierarchy a) - #tail (Base a)])) + #root (Hierarchy of) + #tail (Base of)])) (def .public empty Sequence @@ -207,11 +226,15 @@ #tail (array.empty 0)]) (def .public (size sequence) - (All (_ a) (-> (Sequence a) Nat)) + (All (_ of) + (-> (Sequence of) + Nat)) (the #size sequence)) (def .public (suffix val sequence) - (All (_ a) (-> a (Sequence a) (Sequence a))) + (All (_ of) + (-> of (Sequence of) + (Sequence of))) ... Check if there is room in the tail. (let [sequence_size (the #size sequence)] (if (|> sequence_size (n.- (tail_off sequence_size)) (n.< full_node_size)) @@ -244,7 +267,8 @@ (exception.def incorrect_sequence_structure) (exception.def .public (index_out_of_bounds [sequence index]) - (All (_ a) (Exception [(Sequence a) Nat])) + (All (_ of) + (Exception [(Sequence of) Nat])) (exception.report (.list ["Size" (at n.decimal encoded (the #size sequence))] ["Index" (at n.decimal encoded index)]))) @@ -252,11 +276,15 @@ (exception.def base_was_not_found) (def .public (within_bounds? sequence idx) - (All (_ a) (-> (Sequence a) Nat Bit)) + (All (_ of) + (-> (Sequence of) Nat + Bit)) (n.< (the #size sequence) idx)) (def (base_for idx sequence) - (All (_ a) (-> Index (Sequence a) (Try (Base a)))) + (All (_ of) + (-> Index (Sequence of) + (Try (Base of)))) (if (within_bounds? sequence idx) (if (n.< (tail_off (the #size sequence)) idx) (loop (again [level (the #level sequence) @@ -278,7 +306,9 @@ (exception.except ..index_out_of_bounds [sequence idx]))) (def .public (item idx sequence) - (All (_ a) (-> Nat (Sequence a) (Try a))) + (All (_ of) + (-> Nat (Sequence of) + (Try of))) (do try.monad [base (base_for idx sequence) .let [index (branch_idx idx)]] @@ -287,7 +317,9 @@ {try.#Success (array.item index base)}))) (def .public (has idx val sequence) - (All (_ a) (-> Nat a (Sequence a) (Try (Sequence a)))) + (All (_ of) + (-> Nat of (Sequence of) + (Try (Sequence of)))) (let [sequence_size (the #size sequence)] (if (within_bounds? sequence idx) {try.#Success (if (n.< (tail_off sequence_size) idx) @@ -300,13 +332,17 @@ (exception.except ..index_out_of_bounds [sequence idx])))) (def .public (revised idx revision it) - (All (_ a) (-> Nat (-> a a) (Sequence a) (Try (Sequence a)))) + (All (_ of) + (-> Nat (-> of of) (Sequence of) + (Try (Sequence of)))) (do try.monad [val (..item idx it)] (..has idx (revision val) it))) (def .public (prefix sequence) - (All (_ a) (-> (Sequence a) (Sequence a))) + (All (_ of) + (-> (Sequence of) + (Sequence of))) (when (the #size sequence) 0 empty @@ -351,20 +387,28 @@ )) (def .public (list sequence) - (All (_ a) (-> (Sequence a) (List a))) + (All (_ of) + (-> (Sequence of) + (List of))) (list#composite (node#list {#Hierarchy (the #root sequence)}) (node#list {#Base (the #tail sequence)}))) (def .public of_list - (All (_ a) (-> (List a) (Sequence a))) + (All (_ of) + (-> (List of) + (Sequence of))) (list#mix ..suffix ..empty)) (def .public (member? equivalence sequence val) - (All (_ a) (-> (Equivalence a) (Sequence a) a Bit)) + (All (_ of) + (-> (Equivalence of) (Sequence of) of + Bit)) (list.member? equivalence (list sequence) val)) (def .public empty? - (All (_ a) (-> (Sequence a) Bit)) + (All (_ of) + (-> (Sequence of) + Bit)) (|>> (the #size) (n.= 0))) (def .public sequence @@ -372,7 +416,9 @@ (in (.list (` (..of_list (.list (,* elems)))))))) (def (node_equivalence //#=) - (All (_ a) (-> (Equivalence a) (Equivalence (Node a)))) + (All (_ of) + (-> (Equivalence of) + (Equivalence (Node of)))) (implementation (def (= v1 v2) (when [v1 v2] @@ -386,7 +432,9 @@ false)))) (def .public (equivalence //#=) - (All (_ a) (-> (Equivalence a) (Equivalence (Sequence a)))) + (All (_ of) + (-> (Equivalence of) + (Equivalence (Sequence of)))) (implementation (def (= v1 v2) (and (n.= (the #size v1) (the #size v2)) @@ -423,7 +471,8 @@ {#Base (the #tail xs)}))))) (def .public monoid - (All (_ a) (Monoid (Sequence a))) + (All (_ of) + (Monoid (Sequence of))) (implementation (def identity ..empty) @@ -479,15 +528,18 @@ (mix (function (_ post pre) (composite pre post)) identity))))) (def .public reversed - (All (_ a) (-> (Sequence a) (Sequence a))) + (All (_ of) + (-> (Sequence of) + (Sequence of))) (|>> ..list list.reversed (list#mix suffix ..empty))) (with_template [ ] [(def .public - (All (_ a) - (-> (Predicate a) (Sequence a) Bit)) + (All (_ of) + (-> (Predicate of) (Sequence of) + Bit)) (let [help (is (All (_ a) (-> (Predicate a) (Node a) Bit)) (function (help predicate node) @@ -507,7 +559,9 @@ ) (def .public (only when items) - (All (_ a) (-> (-> a Bit) (Sequence a) (Sequence a))) + (All (_ of) + (-> (-> of Bit) (Sequence of) + (Sequence of))) (..mix (function (_ item output) (if (when item) (..suffix item output) @@ -516,8 +570,9 @@ items)) (def (one|node check items) - (All (_ a b) - (-> (-> a (Maybe b)) (Node a) (Maybe b))) + (All (_ input output) + (-> (-> input (Maybe output)) (Node input) + (Maybe output))) (when items {#Base items} (array.one check items) @@ -526,8 +581,9 @@ (array.one (one|node check) items))) (def .public (one check items) - (All (_ a b) - (-> (-> a (Maybe b)) (Sequence a) (Maybe b))) + (All (_ input output) + (-> (-> input (Maybe output)) (Sequence input) + (Maybe output))) (when (let [... TODO: This binding was established to get around a compilation error. Fix and inline! check (..one|node check)] (|> items @@ -540,3 +596,17 @@ output output)) + +(def .public (all ? it) + (All (_ input output) + (-> (-> input (Maybe output)) (Sequence input) + (Sequence output))) + (..mix (function (_ in out) + (when (? in) + {.#Some in} + (suffix in out) + + {.#None} + out)) + (sequence) + it)) diff --git a/stdlib/source/library/lux/data/format/tar.lux b/stdlib/source/library/lux/data/format/tar.lux index c98ef6ee5..6e5293f67 100644 --- a/stdlib/source/library/lux/data/format/tar.lux +++ b/stdlib/source/library/lux/data/format/tar.lux @@ -16,7 +16,7 @@ ["[1]!" \\unsafe] ["![1]" \\format (.only Format) (.use "[1]#[0]" monoid)] ["?[1]" \\parser (.only Parser)]] - ["[0]" text (.only) + ["[0]" text (.use "[1]#[0]" equivalence) [char (.only Char)] ["%" \\format] [encoding @@ -504,8 +504,6 @@ (def maximum_mode Mode (all and - ..none - ..execute_by_other ..write_by_other ..read_by_other @@ -610,6 +608,33 @@ (type .public Tar (Sequence Entry)) +(exception.def .public (unknown_file path) + (Exception Path) + (exception.report + (list ["Path" (%.text (from_path path))]))) + +(def .public (file expected it) + (-> Path Tar + (Try Binary)) + (when (sequence.one (function (_ it) + (when it + (^.or {#Normal it} + {#Contiguous it}) + (let [[actual _ _ _ content] it] + (if (text#= (from_path expected) + (from_path actual)) + {.#Some (data content)} + {.#None})) + + _ + {.#None})) + it) + {.#Some it} + {try.#Success it} + + {.#None} + (exception.except ..unknown_file [expected]))) + (def (blocks size) (-> Big Nat) (n.+ (n./ ..block_size diff --git a/stdlib/source/library/lux/math/arithmetic.lux b/stdlib/source/library/lux/math/arithmetic.lux new file mode 100644 index 000000000..46488890a --- /dev/null +++ b/stdlib/source/library/lux/math/arithmetic.lux @@ -0,0 +1,22 @@ +(.require + [library + [lux (.except)]]) + +... https://en.wikipedia.org/wiki/Arithmetic +(type .public (Arithmetic of) + (Interface + (is (-> of of + of) + +) + (is (-> of of + of) + -) + (is (-> of of + of) + *) + (is (-> of of + of) + /) + (is (-> of of + of) + %))) diff --git a/stdlib/source/library/lux/math/number/complex.lux b/stdlib/source/library/lux/math/number/complex.lux index c862a952e..518da2518 100644 --- a/stdlib/source/library/lux/math/number/complex.lux +++ b/stdlib/source/library/lux/math/number/complex.lux @@ -17,7 +17,9 @@ ["[0]" code ["<[1]>" \\parser]] [macro - [syntax (.only syntax)]]]]]) + [syntax (.only syntax)]]]]] + [/// + [arithmetic (.only Arithmetic)]]) (type .public Complex (Record @@ -47,12 +49,14 @@ (..complex +0.0 +0.0)) (def .public (not_a_number? complex) - (-> Complex Bit) + (-> Complex + Bit) (or (f.not_a_number? (the #real complex)) (f.not_a_number? (the #imaginary complex)))) (def .public (= param input) - (-> Complex Complex Bit) + (-> Complex Complex + Bit) (and (f.= (the #real param) (the #real input)) (f.= (the #imaginary param) @@ -60,7 +64,8 @@ (with_template [ ] [(def .public ( param input) - (-> Complex Complex Complex) + (-> Complex Complex + Complex) [#real ( (the #real param) (the #real input)) #imaginary ( (the #imaginary param) @@ -77,7 +82,8 @@ (with_template [ ] [(def .public - (-> Complex Complex) + (-> Complex + Complex) (|>> (revised #real ) (revised #imaginary )))] @@ -86,18 +92,21 @@ ) (def .public conjugate - (-> Complex Complex) + (-> Complex + Complex) (revised #imaginary f.opposite)) (def .public (*' param input) - (-> Frac Complex Complex) + (-> Frac Complex + Complex) [#real (f.* param (the #real input)) #imaginary (f.* param (the #imaginary input))]) (def .public (* param input) - (-> Complex Complex Complex) + (-> Complex Complex + Complex) [#real (f.- (f.* (the #imaginary param) (the #imaginary input)) (f.* (the #real param) @@ -108,7 +117,8 @@ (the #real input)))]) (def .public (/ param input) - (-> Complex Complex Complex) + (-> Complex Complex + Complex) (let [(open "[0]") param] (if (f.< (f.abs #imaginary) (f.abs #real)) @@ -122,13 +132,15 @@ ..#imaginary (|> (the ..#imaginary input) (f.- (f.* quot (the ..#real input))) (f./ denom))])))) (def .public (/' param subject) - (-> Frac Complex Complex) + (-> Frac Complex + Complex) (let [(open "[0]") subject] [..#real (f./ param #real) ..#imaginary (f./ param #imaginary)])) (def .public (% param input) - (-> Complex Complex Complex) + (-> Complex Complex + Complex) (let [scaled (/ param input) quotient (|> scaled (revised #real f.floor) @@ -136,8 +148,18 @@ (- (* quotient param) input))) +(def .public arithmetic + (Arithmetic Complex) + (implementation + (def + ..+) + (def - ..-) + (def * ..*) + (def / ../) + (def % ..%))) + (def .public (cos subject) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") subject] [..#real (f.* (f.cosh #imaginary) (f.cos #real)) @@ -145,7 +167,8 @@ (f.sin #real)))])) (def .public (cosh subject) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") subject] [..#real (f.* (f.cos #imaginary) (f.cosh #real)) @@ -153,7 +176,8 @@ (f.sinh #real))])) (def .public (sin subject) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") subject] [..#real (f.* (f.cosh #imaginary) (f.sin #real)) @@ -161,7 +185,8 @@ (f.cos #real))])) (def .public (sinh subject) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") subject] [..#real (f.* (f.cos #imaginary) (f.sinh #real)) @@ -169,7 +194,8 @@ (f.cosh #real))])) (def .public (tan subject) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") subject r2 (f.* +2.0 #real) i2 (f.* +2.0 #imaginary) @@ -178,7 +204,8 @@ ..#imaginary (f./ d (f.sinh i2))])) (def .public (tanh subject) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") subject r2 (f.* +2.0 #real) i2 (f.* +2.0 #imaginary) @@ -187,7 +214,8 @@ ..#imaginary (f./ d (f.sin i2))])) (def .public (abs subject) - (-> Complex Frac) + (-> Complex + Frac) (let [(open "[0]") subject] (if (f.< (f.abs #imaginary) (f.abs #real)) @@ -203,21 +231,24 @@ (f.abs #real))))))) (def .public (exp subject) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") subject r_exp (f.exp #real)] [..#real (f.* r_exp (f.cos #imaginary)) ..#imaginary (f.* r_exp (f.sin #imaginary))])) (def .public (log subject) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") subject] [..#real (|> subject ..abs f.log) ..#imaginary (f.atan_2 #real #imaginary)])) (with_template [ ] [(def .public ( param input) - (-> Complex Complex) + (-> Complex + Complex) (|> input log ( param) exp))] [pow Complex ..*] @@ -225,11 +256,13 @@ ) (def (with_sign sign magnitude) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (f.* (f.signum sign) magnitude)) (def .public (root_2 input) - (-> Complex Complex) + (-> Complex + Complex) (let [(open "[0]") input t (|> input ..abs (f.+ (f.abs #real)) (f./ +2.0) (f.pow +0.5))] (if (f.< +0.0 #real) @@ -241,11 +274,13 @@ #imaginary)]))) (def (root_2-1z input) - (-> Complex Complex) + (-> Complex + Complex) (|> (complex +1.0) (- (* input input)) ..root_2)) (def .public (reciprocal (open "[0]")) - (-> Complex Complex) + (-> Complex + Complex) (if (f.< (f.abs #imaginary) (f.abs #real)) (let [q (f./ #imaginary #real) @@ -260,14 +295,16 @@ ..#imaginary (|> scale f.opposite (f.* q))]))) (def .public (acos input) - (-> Complex Complex) + (-> Complex + Complex) (|> input (..+ (|> input ..root_2-1z (..* ..i))) ..log (..* (..opposite ..i)))) (def .public (asin input) - (-> Complex Complex) + (-> Complex + Complex) (|> input ..root_2-1z (..+ (..* ..i input)) @@ -275,7 +312,8 @@ (..* (..opposite ..i)))) (def .public (atan input) - (-> Complex Complex) + (-> Complex + Complex) (|> input (..+ ..i) (../ (..- input ..i)) @@ -283,11 +321,13 @@ (..* (../ (..complex +2.0) ..i)))) (def .public (argument (open "[0]")) - (-> Complex Frac) + (-> Complex + Frac) (f.atan_2 #real #imaginary)) (def .public (roots nth input) - (-> Nat Complex (List Complex)) + (-> Nat Complex + (List Complex)) (when nth 0 (list) _ (let [r_nth (|> nth .int int.frac) @@ -307,7 +347,8 @@ ..#imaginary imaginary]))))))) (def .public (approximately? margin_of_error standard value) - (-> Frac Complex Complex Bit) + (-> Frac Complex Complex + Bit) (and (f.approximately? margin_of_error (the ..#real standard) (the ..#real value)) diff --git a/stdlib/source/library/lux/math/number/frac.lux b/stdlib/source/library/lux/math/number/frac.lux index afa38b160..481b37e96 100644 --- a/stdlib/source/library/lux/math/number/frac.lux +++ b/stdlib/source/library/lux/math/number/frac.lux @@ -21,7 +21,9 @@ ["[1][0]" i64] ["[1][0]" nat] ["[1][0]" int] - ["[1][0]" rev]]) + ["[1][0]" rev] + [// + [arithmetic (.only Arithmetic)]]]) (with_template [ ] [(def .public @@ -37,7 +39,8 @@ (for @.old (these (with_template [ ] [(def .public ( it) - (-> Frac Frac) + (-> Frac + Frac) ( it))] [cos "jvm invokestatic:java.lang.Math:cos:double"] @@ -57,8 +60,10 @@ [root_2 "jvm invokestatic:java.lang.Math:sqrt:double"] [root_3 "jvm invokestatic:java.lang.Math:cbrt:double"] ) + (def .public (pow param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) ("jvm invokestatic:java.lang.Math:pow:double,double" subject param))) @.jvm @@ -77,7 +82,8 @@ (with_template [ ] [(def .public - (-> Frac Frac) + (-> Frac + Frac) (|>> !double ["D"] (.jvm_member_invoke_static# [] "java.lang.Math" []) @@ -102,7 +108,8 @@ ) (def .public (pow param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (|> (.jvm_member_invoke_static# [] "java.lang.Math" "pow" [] ["D" (!double subject)] ["D" (!double param)]) !frac))) @@ -110,7 +117,8 @@ @.js (these (with_template [ ] [(def .public - (-> Frac Frac) + (-> Frac + Frac) (|>> [] ("js apply" ("js constant" )) (as Frac)))] @@ -134,13 +142,15 @@ ) (def .public (pow param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (as Frac ("js apply" ("js constant" "Math.pow") [subject param])))) @.python (these (with_template [ ] [(def .public - (-> Frac Frac) + (-> Frac + Frac) (|>> [] (.python_object_do# (.python_import# "math")) (as Frac)))] @@ -163,11 +173,13 @@ ) (def .public (pow param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (as Frac (.python_object_do# "pow" (.python_import# "math") [subject param]))) (def .public (root_3 it) - (-> Frac Frac) + (-> Frac + Frac) (if (.f64_<# +0.0 it) (|> it (.f64_*# -1.0) @@ -179,7 +191,8 @@ @.lua (these (with_template [ ] [(def .public - (-> Frac Frac) + (-> Frac + Frac) (|>> [] ("lua apply" ("lua constant" )) (as Frac)))] @@ -202,11 +215,13 @@ ) (def .public (pow param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) ("lua power" param subject)) (def .public (root_3 it) - (-> Frac Frac) + (-> Frac + Frac) (if (.f64_<# +0.0 it) (|> it (.f64_*# -1.0) @@ -218,7 +233,8 @@ @.ruby (these (with_template [ ] [(def .public - (-> Frac Frac) + (-> Frac + Frac) (|>> [] ("ruby apply" ("ruby constant" )) (as Frac)))] @@ -240,7 +256,8 @@ (with_template [ ] [(def .public ( it) - (-> Frac Frac) + (-> Frac + Frac) (|> ("ruby object do" it []) (as Int) (.int_f64#)))] @@ -250,13 +267,15 @@ ) (def .public (pow param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (as Frac ("ruby object do" "**" subject [param])))) @.php (these (with_template [ ] [(def .public - (-> Frac Frac) + (-> Frac + Frac) (|>> ("php apply" ("php constant" )) (as Frac)))] @@ -278,17 +297,20 @@ ) (def .public (pow param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (as Frac ("php apply" ("php constant" "pow") subject param))) (def .public root_3 - (-> Frac Frac) + (-> Frac + Frac) (..pow (.f64_/# +3.0 +1.0)))) @.scheme (these (with_template [ ] [(def .public - (-> Frac Frac) + (-> Frac + Frac) (|>> ("scheme apply" ("scheme constant" )) (as Frac)))] @@ -310,16 +332,19 @@ ) (def .public (pow param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (as Frac ("scheme apply" ("scheme constant" "expt") subject param))) (def .public root_3 - (-> Frac Frac) + (-> Frac + Frac) (..pow (.f64_/# +3.0 +1.0)))) ) (def .public (round it) - (-> Frac Frac) + (-> Frac + Frac) (let [floored (floor it) diff (.f64_-# floored it)] (cond (.f64_<# diff +0.5) @@ -332,7 +357,8 @@ floored))) (def .public (atan_2 x y) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (cond (.f64_<# x +0.0) (..atan (.f64_/# x y)) @@ -353,12 +379,14 @@ (.f64_/# +0.0 +0.0)))) (def .public (log_by base it) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (.f64_/# (..log base) (..log it))) (def .public (factorial it) - (-> Nat Nat) + (-> Nat + Nat) (loop (again [acc 1 it it]) (if (//nat.> 1 it) @@ -366,7 +394,8 @@ acc))) (def .public (hypotenuse catA catB) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (..pow +0.5 (.f64_+# (..pow +2.0 catA) (..pow +2.0 catB)))) @@ -374,11 +403,13 @@ ... https://en.wikipedia.org/wiki/Hyperbolic_function#Definitions (with_template [ ] [(def .public ( it) - (-> Frac Frac) + (-> Frac + Frac) (|> (..exp it) ( (..exp (.f64_*# -1.0 it))) (.f64_/# +2.0))) (def .public ( it) - (-> Frac Frac) + (-> Frac + Frac) (|> +2.0 (.f64_/# (|> (..exp it) ( (..exp (.f64_*# -1.0 it)))))))] [sinh .f64_-# csch] @@ -387,7 +418,8 @@ (with_template [ ] [(def .public ( it) - (-> Frac Frac) + (-> Frac + Frac) (let [e+ (exp it) e- (exp (.f64_*# -1.0 it)) sinh' (|> e+ (.f64_-# e-)) @@ -401,7 +433,8 @@ ... https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions#Definitions_in_terms_of_logarithms (with_template [ ] [(def .public ( it) - (-> Frac Frac) + (-> Frac + Frac) (|> it (pow +2.0) ( +1.0) (pow +0.5) (.f64_+# it) log))] [asinh .f64_+#] @@ -410,7 +443,8 @@ (with_template [ ] [(def .public ( it) - (-> Frac Frac) + (-> Frac + Frac) (let [it+ (|> (.f64_+# )) it- (|> (.f64_-# ))] (|> it+ (.f64_/# it-) log (.f64_/# +2.0))))] @@ -421,7 +455,8 @@ (with_template [ ] [(def .public ( it) - (-> Frac Frac) + (-> Frac + Frac) (let [it^2 (|> it (pow +2.0))] (|> +1.0 ( it^2) (pow +0.5) (.f64_+# +1.0) (.f64_/# it) log)))] @@ -431,7 +466,8 @@ (with_template [ ] [(def .public ( param subject) - (-> Frac Frac Bit) + (-> Frac Frac + Bit) ( param subject))] [= .f64_=#] @@ -439,16 +475,19 @@ ) (def .public (<= reference sample) - (-> Frac Frac Bit) + (-> Frac Frac + Bit) (or (.f64_<# reference sample) (.f64_=# reference sample))) (def .public (> reference sample) - (-> Frac Frac Bit) + (-> Frac Frac + Bit) (.f64_<# sample reference)) (def .public (>= reference sample) - (-> Frac Frac Bit) + (-> Frac Frac + Bit) (or (.f64_<# sample reference) (.f64_=# sample reference))) @@ -464,7 +503,8 @@ (with_template [ ] [(def .public ( param subject) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) ( param subject))] [+ .f64_+#] @@ -474,23 +514,36 @@ [% .f64_%#] ) +(def .public arithmetic + (Arithmetic Frac) + (implementation + (def + ..+) + (def - ..-) + (def * ..*) + (def / ../) + (def % ..%))) + (def .public (/% param subject) - (-> Frac Frac [Frac Frac]) + (-> Frac Frac + [Frac Frac]) [(../ param subject) (..% param subject)]) (def .public opposite - (-> Frac Frac) + (-> Frac + Frac) (..* -1.0)) (def .public (abs it) - (-> Frac Frac) + (-> Frac + Frac) (if (..< +0.0 it) (..* -1.0 it) it)) (def .public (signum it) - (-> Frac Frac) + (-> Frac + Frac) (cond (..= +0.0 it) +0.0 (..< +0.0 it) -1.0 ... else @@ -501,7 +554,8 @@ (with_template [ ] [(def .public ( left right) - (-> Frac Frac Frac) + (-> Frac Frac + Frac) (if ( right left) left right))] @@ -511,11 +565,13 @@ ) (def .public nat - (-> Frac Nat) + (-> Frac + Nat) (|>> .f64_int# .nat)) (def .public int - (-> Frac Int) + (-> Frac + Int) (|>> .f64_int#)) (def mantissa_size Nat 52) @@ -527,7 +583,8 @@ .int_f64#)) (def .public rev - (-> Frac Rev) + (-> Frac + Rev) (|>> ..abs (..% +1.0) (..* ..frac_denominator) @@ -548,11 +605,13 @@ (..* -1.0 ..positive_infinity)) (def .public (not_a_number? it) - (-> Frac Bit) + (-> Frac + Bit) (not (..= it it))) (def .public (number? it) - (-> Frac Bit) + (-> Frac + Bit) (not (or (..not_a_number? it) (..= ..positive_infinity it) (..= ..negative_infinity it)))) @@ -619,7 +678,8 @@ {try.#Failure "Could not decode Frac"})))) (def log/2 - (-> Frac Frac) + (-> Frac + Frac) (|>> ..log (../ (..log +2.0)))) @@ -649,7 +709,8 @@ (..log/2 ..smallest)) (def .public (bits it) - (-> Frac I64) + (-> Frac + I64) (.i64 (cond (..not_a_number? it) ..not_a_number_bits @@ -702,7 +763,8 @@ (with_template [ ] [(def - (-> (I64 Any) I64) + (-> (I64 Any) + I64) (let [mask (|> 1 (//i64.left_shifted ) -- (//i64.left_shifted ))] (|>> (//i64.and mask) (//i64.right_shifted ) .i64)))] @@ -712,7 +774,8 @@ ) (def .public (of_bits it) - (-> I64 Frac) + (-> I64 + Frac) (when [(is Nat (..exponent it)) (is Nat (..mantissa it)) (is Nat (..sign it))] @@ -751,7 +814,8 @@ (..* sign))))) (`` (def (representation_exponent codec representation) - (-> (Codec Text Nat) Text (Try [Text Int])) + (-> (Codec Text Nat) Text + (Try [Text Int])) (when [(.text_index# 0 "e+" representation) (.text_index# 0 "E+" representation) (.text_index# 0 "e-" representation) @@ -836,14 +900,15 @@ (def hash ..bits))) (def .public (approximately? margin_of_error standard value) - (-> Frac Frac Frac Bit) + (-> Frac Frac Frac + Bit) (|> value (..- standard) ..abs (..< margin_of_error))) (def .public (mod divisor dividend) - (All (_ m) (-> Frac Frac Frac)) + (-> Frac Frac Frac) (let [remainder (..% divisor dividend)] (if (or (and (..< +0.0 divisor) (..> +0.0 remainder)) diff --git a/stdlib/source/library/lux/math/number/int.lux b/stdlib/source/library/lux/math/number/int.lux index 4de53bfe9..bd1c852b0 100644 --- a/stdlib/source/library/lux/math/number/int.lux +++ b/stdlib/source/library/lux/math/number/int.lux @@ -16,11 +16,14 @@ [predicate (.only Predicate)]]]]] ["[0]" // ["[1][0]" nat] - ["[1][0]" i64]]) + ["[1][0]" i64] + [// + [arithmetic (.only Arithmetic)]]]) (with_template [ ] [(def .public ( param subject) - (-> Int Int Bit) + (-> Int Int + Bit) ( param subject))] [= .i64_=#] @@ -28,17 +31,20 @@ ) (def .public (<= reference sample) - (-> Int Int Bit) + (-> Int Int + Bit) (if (.int_<# reference sample) true (.i64_=# reference sample))) (def .public (> reference sample) - (-> Int Int Bit) + (-> Int Int + Bit) (.int_<# sample reference)) (def .public (>= reference sample) - (-> Int Int Bit) + (-> Int Int + Bit) (if (.int_<# sample reference) true (.i64_=# reference sample))) @@ -55,7 +61,8 @@ (with_template [ ] [(def .public ( left right) - (-> Int Int Int) + (-> Int Int + Int) (if ( right left) left right))] @@ -66,7 +73,8 @@ (with_template [ ] [(def .public ( param subject) - (-> Int Int Int) + (-> Int Int + Int) ( param subject))] [+ .i64_+#] @@ -76,23 +84,36 @@ [% .int_%#] ) +(def .public arithmetic + (Arithmetic Int) + (implementation + (def + ..+) + (def - ..-) + (def * ..*) + (def / ../) + (def % ..%))) + (def .public (/% param subject) - (-> Int Int [Int Int]) + (-> Int Int + [Int Int]) [(../ param subject) (..% param subject)]) (def .public (opposite it) - (-> Int Int) + (-> Int + Int) (..- it +0)) (def .public (abs it) - (-> Int Int) + (-> Int + Int) (if (..< +0 it) (..* -1 it) it)) (def .public (signum it) - (-> Int Int) + (-> Int + Int) (cond (..= +0 it) +0 (..< +0 it) -1 ... else @@ -100,7 +121,8 @@ ... https://rob.conery.io/2018/08/21/mod-and-remainder-are-not-the-same/ (def .public (mod divisor dividend) - (All (_ m) (-> Int Int Int)) + (-> Int Int + Int) (let [remainder (..% divisor dividend)] (if (or (and (..< +0 divisor) (..> +0 remainder)) @@ -110,27 +132,32 @@ remainder))) (def .public even? - (-> Int Bit) + (-> Int + Bit) (|>> (..% +2) (.i64_=# +0))) (def .public odd? - (-> Int Bit) + (-> Int + Bit) (|>> ..even? not)) ... https://en.wikipedia.org/wiki/Greatest_common_divisor (def .public (gcd a b) - (-> Int Int Int) + (-> Int Int + Int) (when b +0 a _ (gcd b (..% b a)))) (def .public (co_prime? a b) - (-> Int Int Bit) + (-> Int Int + Bit) (..= +1 (..gcd a b))) ... https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm (def .public (extended_gcd a b) - (-> Int Int [[Int Int] Int]) + (-> Int Int + [[Int Int] Int]) (loop (again [x +1 x1 +0 y +0 y1 +1 a1 a b1 b]) @@ -143,7 +170,8 @@ ... https://en.wikipedia.org/wiki/Least_common_multiple (`` (def .public (lcm a b) - (-> Int Int Int) + (-> Int Int + Int) (when [a b] (,, (with_template [] [ @@ -156,7 +184,8 @@ (|> a (/ (gcd a b)) (* b))))) (def .public frac - (-> Int Frac) + (-> Int + Frac) (|>> .int_f64#)) (def .public equivalence @@ -249,7 +278,8 @@ (def hash (|>> .nat)))) (def .public (right_shifted parameter subject) - (-> Nat Int Int) + (-> Nat Int + Int) (with_expansions [ (//i64.right_shifted parameter subject)] (if (< +0 subject) (|> +1 diff --git a/stdlib/source/library/lux/math/number/nat.lux b/stdlib/source/library/lux/math/number/nat.lux index 66c29f167..1464fc8e9 100644 --- a/stdlib/source/library/lux/math/number/nat.lux +++ b/stdlib/source/library/lux/math/number/nat.lux @@ -12,11 +12,14 @@ [control ["[0]" function] ["[0]" maybe] - ["[0]" try (.only Try)]]]]) + ["[0]" try (.only Try)]]]] + [/// + [arithmetic (.only Arithmetic)]]) (with_template [ ] [(def .public ( parameter subject) - (-> Nat Nat ) + (-> Nat Nat + ) ( parameter subject))] [.i64_=# Bit =] @@ -25,16 +28,19 @@ ) (def high - (-> (I64 Any) I64) + (-> (I64 Any) + I64) (|>> (.i64_right# 32))) (def low - (-> (I64 Any) I64) + (-> (I64 Any) + I64) (let [mask (|> 1 (.i64_left# 32) (.i64_-# 1))] (|>> (.i64_and# mask)))) (def .public (< reference sample) - (-> Nat Nat Bit) + (-> Nat Nat + Bit) (let [referenceH (..high reference) sampleH (..high sample)] (if (.int_<# referenceH sampleH) @@ -46,22 +52,26 @@ false)))) (def .public (<= reference sample) - (-> Nat Nat Bit) + (-> Nat Nat + Bit) (or (..< reference sample) (.i64_=# reference sample))) (def .public (> reference sample) - (-> Nat Nat Bit) + (-> Nat Nat + Bit) (..< sample reference)) (def .public (>= reference sample) - (-> Nat Nat Bit) + (-> Nat Nat + Bit) (or (..< sample reference) (.i64_=# reference sample))) (with_template [ ] [(def .public ( left right) - (-> Nat Nat Nat) + (-> Nat Nat + Nat) (if ( right left) left right))] @@ -71,12 +81,14 @@ ) (def .public (* parameter subject) - (-> Nat Nat Nat) + (-> Nat Nat + Nat) (.nat (.int_*# (.int parameter) (.int subject)))) (def .public (/ parameter subject) - (-> Nat Nat Nat) + (-> Nat Nat + Nat) (if (.int_<# +0 (.int parameter)) (if (..< parameter subject) 0 @@ -93,30 +105,44 @@ (.i64_+# 1 quotient))))) (def .public (/% parameter subject) - (-> Nat Nat [Nat Nat]) + (-> Nat Nat + [Nat Nat]) (let [quotient (../ parameter subject) flat (.int_*# (.int parameter) (.int quotient))] [quotient (.i64_-# flat subject)])) (def .public (% parameter subject) - (-> Nat Nat Nat) + (-> Nat Nat + Nat) (let [flat (.int_*# (.int parameter) (.int (../ parameter subject)))] (.i64_-# flat subject))) +(def .public arithmetic + (Arithmetic Nat) + (implementation + (def + ..+) + (def - ..-) + (def * ..*) + (def / ../) + (def % ..%))) + (def .public (gcd a b) - (-> Nat Nat Nat) + (-> Nat Nat + Nat) (when b 0 a _ (gcd b (..% b a)))) (def .public (co_prime? a b) - (-> Nat Nat Bit) + (-> Nat Nat + Bit) (..= 1 (..gcd a b))) (`` (def .public (lcm a b) - (-> Nat Nat Nat) + (-> Nat Nat + Nat) (when [a b] (,, (with_template [] [ @@ -129,15 +155,18 @@ (|> a (../ (..gcd a b)) (..* b))))) (def .public even? - (-> Nat Bit) + (-> Nat + Bit) (|>> (..% 2) (.i64_=# 0))) (def .public odd? - (-> Nat Bit) + (-> Nat + Bit) (|>> ..even? not)) (def .public frac - (-> Nat Frac) + (-> Nat + Frac) (|>> .int .int_f64#)) (def .public equivalence @@ -179,21 +208,24 @@ ) (def (binary_character value) - (-> Nat Text) + (-> Nat + Text) (when value 0 "0" 1 "1" _ (undefined))) (def (binary_value digit) - (-> Nat (Maybe Nat)) + (-> Nat + (Maybe Nat)) (when digit (char "0") {.#Some 0} (char "1") {.#Some 1} _ {.#None})) (def (octal_character value) - (-> Nat Text) + (-> Nat + Text) (when value 0 "0" 1 "1" @@ -206,7 +238,8 @@ _ (undefined))) (def (octal_value digit) - (-> Nat (Maybe Nat)) + (-> Nat + (Maybe Nat)) (when digit (char "0") {.#Some 0} (char "1") {.#Some 1} @@ -219,7 +252,8 @@ _ {.#None})) (def (decimal_character value) - (-> Nat Text) + (-> Nat + Text) (when value 0 "0" 1 "1" @@ -234,7 +268,8 @@ _ (undefined))) (def (decimal_value digit) - (-> Nat (Maybe Nat)) + (-> Nat + (Maybe Nat)) (when digit (char "0") {.#Some 0} (char "1") {.#Some 1} @@ -249,7 +284,8 @@ _ {.#None})) (def (hexadecimal_character value) - (-> Nat Text) + (-> Nat + Text) (when value 0 "0" 1 "1" @@ -270,7 +306,8 @@ _ (undefined))) (`` (def (hexadecimal_value digit) - (-> Nat (Maybe Nat)) + (-> Nat + (Maybe Nat)) (when digit (,, (with_template [ ] [(char ) diff --git a/stdlib/source/library/lux/math/number/ratio.lux b/stdlib/source/library/lux/math/number/ratio.lux index 2974eae8b..f24598300 100644 --- a/stdlib/source/library/lux/math/number/ratio.lux +++ b/stdlib/source/library/lux/math/number/ratio.lux @@ -21,7 +21,9 @@ [macro [syntax (.only syntax)]]]]] [// - ["n" nat (.use "[1]#[0]" decimal)]]) + ["n" nat (.use "[1]#[0]" decimal)] + [// + [arithmetic (.only Arithmetic)]]]) (type .public Ratio (Record @@ -29,13 +31,15 @@ #denominator Nat])) (def .public (nat value) - (-> Ratio (Maybe Nat)) + (-> Ratio + (Maybe Nat)) (when (the #denominator value) 1 {.#Some (the #numerator value)} _ {.#None})) (def .public (normal (open "_[0]")) - (-> Ratio Ratio) + (-> Ratio + Ratio) (let [common (n.gcd _#numerator _#denominator)] [..#numerator (n./ common _#numerator) ..#denominator (n./ common _#denominator)])) @@ -47,7 +51,8 @@ ..#denominator (, (maybe.else (' 1) ?denominator))])))))) (def .public (= parameter subject) - (-> Ratio Ratio Bit) + (-> Ratio Ratio + Bit) (and (n.= (the #numerator parameter) (the #numerator subject)) (n.= (the #denominator parameter) @@ -59,28 +64,33 @@ (def = ..=))) (def (equalized parameter subject) - (-> Ratio Ratio [Nat Nat]) + (-> Ratio Ratio + [Nat Nat]) [(n.* (the #denominator subject) (the #numerator parameter)) (n.* (the #denominator parameter) (the #numerator subject))]) (def .public (< parameter subject) - (-> Ratio Ratio Bit) + (-> Ratio Ratio + Bit) (let [[parameter' subject'] (..equalized parameter subject)] (n.< parameter' subject'))) (def .public (<= parameter subject) - (-> Ratio Ratio Bit) + (-> Ratio Ratio + Bit) (or (< parameter subject) (= parameter subject))) (def .public (> parameter subject) - (-> Ratio Ratio Bit) + (-> Ratio Ratio + Bit) (..< subject parameter)) (def .public (>= parameter subject) - (-> Ratio Ratio Bit) + (-> Ratio Ratio + Bit) (or (> parameter subject) (= parameter subject))) @@ -91,40 +101,55 @@ (def < ..<))) (def .public (+ parameter subject) - (-> Ratio Ratio Ratio) + (-> Ratio Ratio + Ratio) (let [[parameter' subject'] (..equalized parameter subject)] (normal [(n.+ parameter' subject') (n.* (the #denominator parameter) (the #denominator subject))]))) (def .public (- parameter subject) - (-> Ratio Ratio Ratio) + (-> Ratio Ratio + Ratio) (let [[parameter' subject'] (..equalized parameter subject)] (normal [(n.- parameter' subject') (n.* (the #denominator parameter) (the #denominator subject))]))) (def .public (* parameter subject) - (-> Ratio Ratio Ratio) + (-> Ratio Ratio + Ratio) (normal [(n.* (the #numerator parameter) (the #numerator subject)) (n.* (the #denominator parameter) (the #denominator subject))])) (def .public (/ parameter subject) - (-> Ratio Ratio Ratio) + (-> Ratio Ratio + Ratio) (let [[parameter' subject'] (..equalized parameter subject)] (normal [subject' parameter']))) (def .public (% parameter subject) - (-> Ratio Ratio Ratio) + (-> Ratio Ratio + Ratio) (let [[parameter' subject'] (..equalized parameter subject) quot (n./ parameter' subject')] (..- (revised #numerator (n.* quot) parameter) subject))) +(def .public arithmetic + (Arithmetic Ratio) + (implementation + (def + ..+) + (def - ..-) + (def * ..*) + (def / ../) + (def % ..%))) + (def .public (reciprocal (open "_[0]")) - (-> Ratio Ratio) + (-> Ratio + Ratio) [..#numerator _#denominator ..#denominator _#numerator]) diff --git a/stdlib/source/library/lux/math/number/rev.lux b/stdlib/source/library/lux/math/number/rev.lux index 47b3f52db..070c284b5 100644 --- a/stdlib/source/library/lux/math/number/rev.lux +++ b/stdlib/source/library/lux/math/number/rev.lux @@ -18,7 +18,9 @@ ["[0]" // ["[1][0]" i64] ["[1][0]" nat] - ["[1][0]" int]]) + ["[1][0]" int] + [// + [arithmetic (.only Arithmetic)]]]) (def .public /1 Rev @@ -44,30 +46,36 @@ ) (def .public (= reference sample) - (-> Rev Rev Bit) + (-> Rev Rev + Bit) (.i64_=# reference sample)) (def .public (< reference sample) - (-> Rev Rev Bit) + (-> Rev Rev + Bit) (//nat.< (.nat reference) (.nat sample))) (def .public (<= reference sample) - (-> Rev Rev Bit) + (-> Rev Rev + Bit) (or (//nat.< (.nat reference) (.nat sample)) (.i64_=# reference sample))) (def .public (> reference sample) - (-> Rev Rev Bit) + (-> Rev Rev + Bit) (..< sample reference)) (def .public (>= reference sample) - (-> Rev Rev Bit) + (-> Rev Rev + Bit) (or (..< sample reference) (.i64_=# reference sample))) (with_template [ ] [(def .public ( left right) - (-> Rev Rev Rev) + (-> Rev Rev + Rev) (if ( right left) left right))] @@ -78,7 +86,8 @@ (with_template [ ] [(def .public ( param subject) - (-> Rev Rev Rev) + (-> Rev Rev + Rev) ( param subject))] [+ .i64_+#] @@ -86,16 +95,19 @@ ) (def high - (-> (I64 Any) I64) + (-> (I64 Any) + I64) (|>> (.i64_right# 32))) (def low - (-> (I64 Any) I64) + (-> (I64 Any) + I64) (let [mask (|> 1 (.i64_left# 32) (.i64_-# 1))] (|>> (.i64_and# mask)))) (def .public (* param subject) - (-> Rev Rev Rev) + (-> Rev Rev + Rev) (let [subjectH (..high subject) subjectL (..low subject) paramH (..high param) @@ -115,23 +127,27 @@ (def odd_one (-- 0)) (def (even_reciprocal numerator) - (-> Nat Nat) + (-> Nat + Nat) (//nat./ (//i64.right_shifted 1 numerator) ..even_one)) (def (odd_reciprocal numerator) - (-> Nat Nat) + (-> Nat + Nat) (//nat./ numerator ..odd_one)) (with_expansions [ 1] (def .public (reciprocal numerator) - (-> Nat Rev) + (-> Nat + Rev) (.rev (when (is Nat (.i64_and# numerator)) 0 (..even_reciprocal numerator) _ (..odd_reciprocal numerator)))) (def .public (/ param subject) - (-> Rev Rev Rev) + (-> Rev Rev + Rev) (if (.i64_=# +0 param) (panic! "Cannot divide Rev by zero!") (let [reciprocal (when (is Nat (.i64_and# param)) @@ -141,16 +157,27 @@ (with_template [ ] [(def .public ( param subject) - (-> Rev Rev ) + (-> Rev Rev + ) ( ( (.nat param) (.nat subject))))] [//nat.% % .rev Rev] [//nat./ ratio |> Nat] ) +(def .public arithmetic + (Arithmetic Rev) + (implementation + (def + ..+) + (def - ..-) + (def * ..*) + (def / ../) + (def % ..%))) + (with_template [ ] [(def .public ( scale subject) - (-> Nat Rev Rev) + (-> Nat Rev + Rev) (.rev ( (.nat scale) (.nat subject))))] [//nat.* up] @@ -158,12 +185,14 @@ ) (def .public (/% param subject) - (-> Rev Rev [Rev Rev]) + (-> Rev Rev + [Rev Rev]) [(../ param subject) (..% param subject)]) (def mantissa - (-> (I64 Any) Frac) + (-> (I64 Any) + Frac) (|>> (.i64_right# 11) .int_f64#)) @@ -171,7 +200,8 @@ (..mantissa -1)) (def .public frac - (-> Rev Frac) + (-> Rev + Frac) (|>> ..mantissa (.f64_/# ..frac_denominator))) (def .public equivalence @@ -218,7 +248,8 @@ ) (def (decimals input) - (-> Text Text) + (-> Text + Text) (.text_clip# 1 (-- (.text_size# input)) input)) (with_template [ ] @@ -279,21 +310,25 @@ (Array Nat)) (def (digits _) - (-> Any Digits) + (-> Any + Digits) (array.empty //i64.width)) (def (digit idx digits) - (-> Nat Digits Nat) + (-> Nat Digits + Nat) (|> digits (array.item idx) (maybe.else 0))) (def digits#put! - (-> Nat Nat Digits Digits) + (-> Nat Nat Digits + Digits) array.has!) (def (digits#times_5! idx output) - (-> Nat Digits Digits) + (-> Nat Digits + Digits) (loop (again [idx idx carry 0 output output]) @@ -307,7 +342,8 @@ (digits#put! idx (//nat.% 10 raw) output)))))) (def (power_digits power) - (-> Nat Digits) + (-> Nat + Digits) (loop (again [times power output (|> (..digits []) (digits#put! power 1))]) @@ -317,7 +353,8 @@ (digits#times_5! power output))))) (def (format digits) - (-> Digits Text) + (-> Digits + Text) (loop (again [idx (-- //i64.width) all_zeroes? true output ""]) @@ -335,7 +372,8 @@ output))))))) (def (digits#+! param subject) - (-> Digits Digits Digits) + (-> Digits Digits + Digits) (loop (again [idx (-- //i64.width) carry 0 output (..digits [])]) @@ -350,7 +388,8 @@ (digits#put! idx (//nat.% 10 raw) output)))))) (def (text_digits input) - (-> Text (Maybe Digits)) + (-> Text + (Maybe Digits)) (let [length (.text_size# input)] (if (//nat.> //i64.width length) {.#None} @@ -367,7 +406,8 @@ {.#Some output}))))) (def (digits#< param subject) - (-> Digits Digits Bit) + (-> Digits Digits + Bit) (loop (again [idx 0]) (and (//nat.< //i64.width idx) (let [pd (..digit idx param) @@ -377,7 +417,8 @@ (//nat.< pd sd)))))) (def (digits#-!' idx param subject) - (-> Nat Nat Digits Digits) + (-> Nat Nat Digits + Digits) (let [sd (..digit idx subject)] (if (//nat.< param sd) (let [diff (|> sd @@ -389,7 +430,8 @@ (digits#put! idx (//nat.- param sd) subject)))) (def (digits#-! param subject) - (-> Digits Digits Digits) + (-> Digits Digits + Digits) (loop (again [idx (-- //i64.width) output subject]) (if (//int.< +0 (.int idx)) diff --git a/stdlib/source/library/lux/meta/compiler/default/platform.lux b/stdlib/source/library/lux/meta/compiler/default/platform.lux index 4dad1b450..c245fbc26 100644 --- a/stdlib/source/library/lux/meta/compiler/default/platform.lux +++ b/stdlib/source/library/lux/meta/compiler/default/platform.lux @@ -232,7 +232,7 @@ (the #phase platform))] _ (is (Async (Try Any)) (cache.enable! async.monad (the #file_system platform) context)) - [archive analysis_state bundles] (ioW.thaw (list) compilation_configuration (the #host platform) (the #file_system platform) context import compilation_sources) + [archive analysis_state] (ioW.thaw (list) compilation_configuration (the #host platform) (the #file_system platform) context import compilation_sources) .let [with_missing_extensions (is (All (_ ) (-> (//init.Extensions ) (Async (Try )))) diff --git a/stdlib/source/library/lux/meta/compiler/language/lux/phase/extension/declaration/lux.lux b/stdlib/source/library/lux/meta/compiler/language/lux/phase/extension/declaration/lux.lux index 99a99baa6..3bda50cd1 100644 --- a/stdlib/source/library/lux/meta/compiler/language/lux/phase/extension/declaration/lux.lux +++ b/stdlib/source/library/lux/meta/compiler/language/lux/phase/extension/declaration/lux.lux @@ -173,54 +173,6 @@ (synthesis archive codeA))] (definition' archive translation name code//type codeS))) -(with_template [ ] - [... TODO: Inline "" into "" ASAP - (def ( archive translation extension codeT codeS) - (All (_ anchor expression declaration) - (-> Archive - (/////translation.Phase anchor expression declaration) - Text - Type - Synthesis - (Operation anchor expression declaration [expression Any]))) - (do phase.monad - [current_module (/////declaration.of_analysis meta.current_module_name)] - (/////declaration.of_translation - (do phase.monad - [dependencies (cache/artifact.dependencies archive codeS) - [interim_artifacts codeG] (/////translation.with_interim_artifacts archive - (translation archive codeS)) - @module (phase.of_try (archive.id current_module archive)) - @self ( extension (list#mix set.has dependencies interim_artifacts)) - [target_name value declaration] (/////translation.define! [@module @self] {.#None} [{.#None} codeG]) - _ (/////translation.save! @self {.#None} declaration)] - (in [codeG value]))))) - - (def .public ( archive extension codeT codeC) - (All (_ anchor expression declaration) - (-> Archive Text Type Code - (Operation anchor expression declaration [expression Any]))) - (do phase.monad - [state phase.state - .let [analysis_state (the [/////declaration.#analysis /////declaration.#state] state) - analysis (the [/////declaration.#analysis /////declaration.#phase] state) - synthesis ((the [/////declaration.#synthesis /////declaration.#phase] state) analysis_state) - translation ((the [/////declaration.#translation /////declaration.#phase] state) analysis_state)] - [_ codeA] (<| /////declaration.of_analysis - scope.with - typeA.fresh - (typeA.expecting codeT) - (analysis archive codeC)) - codeS (/////declaration.of_synthesis - (synthesis archive codeA))] - ( archive translation extension codeT codeS)))] - - [analyser analyser' /////translation.learn_analyser] - [synthesizer synthesizer' /////translation.learn_synthesizer] - [translator translator' /////translation.learn_translator] - [declaration declaration' /////translation.learn_declaration] - ) - ... TODO: Get rid of this function ASAP. (def refresh (All (_ anchor expression declaration) diff --git a/stdlib/source/library/lux/meta/compiler/language/lux/translation.lux b/stdlib/source/library/lux/meta/compiler/language/lux/translation.lux index bf2e4f0f3..c69086b06 100644 --- a/stdlib/source/library/lux/meta/compiler/language/lux/translation.lux +++ b/stdlib/source/library/lux/meta/compiler/language/lux/translation.lux @@ -266,10 +266,6 @@ [category.Definition mandatory? [mandatory?] [Bit] learn registry.definition] [Text #1 [] [] learn_custom registry.custom] - [Text #0 [] [] learn_analyser registry.analyser] - [Text #0 [] [] learn_synthesizer registry.synthesizer] - [Text #0 [] [] learn_translator registry.translator] - [Text #0 [] [] learn_declaration registry.declaration] ) (exception.def .public (unknown_definition [name known_definitions]) diff --git a/stdlib/source/library/lux/meta/compiler/meta/archive/artifact/category.lux b/stdlib/source/library/lux/meta/compiler/meta/archive/artifact/category.lux index 7ce614c92..0b3758826 100644 --- a/stdlib/source/library/lux/meta/compiler/meta/archive/artifact/category.lux +++ b/stdlib/source/library/lux/meta/compiler/meta/archive/artifact/category.lux @@ -35,10 +35,6 @@ (Variant {#Anonymous} {#Definition Definition} - {#Analyser Text} - {#Synthesizer Text} - {#Translator Text} - {#Declaration Text} {#Custom Text})) (def .public equivalence @@ -52,14 +48,9 @@ [{#Definition left} {#Definition right}] (at definition_equivalence = left right) - (^.with_template [] - [[{ left} { right}] - (text#= left right)]) - ([#Analyser] - [#Synthesizer] - [#Translator] - [#Declaration] - [#Custom]) + [{#Custom left} {#Custom right}] + (text#= left right) _ - false)))) + false + )))) diff --git a/stdlib/source/library/lux/meta/compiler/meta/archive/registry.lux b/stdlib/source/library/lux/meta/compiler/meta/archive/registry.lux index 3ca43494f..93e18387a 100644 --- a/stdlib/source/library/lux/meta/compiler/meta/archive/registry.lux +++ b/stdlib/source/library/lux/meta/compiler/meta/archive/registry.lux @@ -88,10 +88,6 @@ [//category.#Definition definition definitions //category.Definition product.left {.#Some it}] - [//category.#Analyser analyser analysers Text |> {.#None}] - [//category.#Synthesizer synthesizer synthesizers Text |> {.#None}] - [//category.#Translator translator translators Text |> {.#None}] - [//category.#Declaration declaration declarations Text |> {.#None}] [//category.#Custom custom customs Text |> {.#None}] ) @@ -125,11 +121,7 @@ ((binary.and binary.nat ) [ value])]) ([0 //category.#Anonymous binary.any] [1 //category.#Definition definition] - [2 //category.#Analyser binary.text] - [3 //category.#Synthesizer binary.text] - [4 //category.#Translator binary.text] - [5 //category.#Declaration binary.text] - [6 //category.#Custom binary.text])))) + [2 //category.#Custom binary.text])))) mandatory? binary.bit dependency (is (Format unit.ID) (binary.and binary.nat binary.nat)) @@ -171,11 +163,7 @@ (at ! each (|>> {}) )]) ([0 //category.#Anonymous .any] [1 //category.#Definition definition] - [2 //category.#Analyser .text] - [3 //category.#Synthesizer .text] - [4 //category.#Translator .text] - [5 //category.#Declaration .text] - [6 //category.#Custom .text]) + [2 //category.#Custom .text]) _ (<>.failure (exception.error ..invalid_category [tag]))))) mandatory? .bit @@ -194,10 +182,6 @@ [{ name} ( name mandatory? dependencies registry)]) ([//category.#Definition ..definition] - [//category.#Analyser ..analyser] - [//category.#Synthesizer ..synthesizer] - [//category.#Translator ..translator] - [//category.#Declaration ..declaration] [//category.#Custom ..custom]) ))) ..empty))))) diff --git a/stdlib/source/library/lux/meta/compiler/meta/io/archive.lux b/stdlib/source/library/lux/meta/compiler/meta/io/archive.lux index 02a205b27..37f0435ab 100644 --- a/stdlib/source/library/lux/meta/compiler/meta/io/archive.lux +++ b/stdlib/source/library/lux/meta/compiler/meta/io/archive.lux @@ -89,135 +89,57 @@ (archive.archived archive)))] (in (has .#modules modules (fresh_analysis_state host configuration))))) -(type Definitions (Dictionary Text Any)) -(type Analysers (Dictionary Text analysis.Handler)) -(type Synthesizers (Dictionary Text synthesis.Handler)) -(type Translators (Dictionary Text translation.Handler)) -(type Declarations (Dictionary Text declaration.Handler)) - -(type Bundles - [Analysers - Synthesizers - Translators - Declarations]) - -(def empty_bundles - Bundles - [(dictionary.empty text.hash) - (dictionary.empty text.hash) - (dictionary.empty text.hash) - (dictionary.empty text.hash)]) +(type Definitions + (Dictionary Text Any)) (def (loaded_document extension host @module expected actual document) (All (_ expression declaration) (-> Text (translation.Host expression declaration) module.ID (Sequence [Artifact (Set unit.ID)]) (Dictionary Text Binary) (Document .Module) - (Try [(Document .Module) Bundles Output]))) + (Try [(Document .Module) Output]))) (do [! try.monad] - [[definitions bundles] (is (Try [Definitions Bundles Output]) - (loop (again [input (sequence.list expected) - definitions (is Definitions - (dictionary.empty text.hash)) - bundles ..empty_bundles - output (is Output sequence.empty)]) - (let [[analysers synthesizers translators declarations] bundles] - (when input - {.#Item [[[@artifact artifact_category mandatory_artifact?] artifact_dependencies] input']} - (when (do ! - [data (try.of_maybe (dictionary.value (format (%.nat @artifact) extension) actual)) - .let [context [@module @artifact] - declaration (at host ingest context data)]] - (when artifact_category - {category.#Anonymous} - (do ! - [.let [output (sequence.suffix [@artifact {.#None} data] output)] - _ (at host re_learn context {.#None} declaration)] - (in [definitions - [analysers - synthesizers - translators - declarations] - output])) - - {category.#Definition [name function_artifact]} - (let [output (sequence.suffix [@artifact {.#None} data] output)] - (if (text#= $/program.name name) - (in [definitions - [analysers - synthesizers - translators - declarations] - output]) - (do ! - [value (at host re_load context {.#None} declaration)] - (in [(dictionary.has name value definitions) - [analysers - synthesizers - translators - declarations] - output])))) - - {category.#Analyser extension} - (do ! - [.let [output (sequence.suffix [@artifact {.#None} data] output)] - value (at host re_load context {.#None} declaration)] - (in [definitions - [(dictionary.has extension (as analysis.Handler value) analysers) - synthesizers - translators - declarations] - output])) - - {category.#Synthesizer extension} - (do ! - [.let [output (sequence.suffix [@artifact {.#None} data] output)] - value (at host re_load context {.#None} declaration)] - (in [definitions - [analysers - (dictionary.has extension (as synthesis.Handler value) synthesizers) - translators - declarations] - output])) - - {category.#Translator extension} - (do ! - [.let [output (sequence.suffix [@artifact {.#None} data] output)] - value (at host re_load context {.#None} declaration)] - (in [definitions - [analysers - synthesizers - (dictionary.has extension (as translation.Handler value) translators) - declarations] - output])) - - {category.#Declaration extension} - (do ! - [.let [output (sequence.suffix [@artifact {.#None} data] output)] - value (at host re_load context {.#None} declaration)] - (in [definitions - [analysers - synthesizers - translators - (dictionary.has extension (as declaration.Handler value) declarations)] - output])) + [[definitions output] (is (Try [Definitions Output]) + (loop (again [input (sequence.list expected) + definitions (is Definitions + (dictionary.empty text.hash)) + output (is Output sequence.empty)]) + (when input + {.#Item [[[@artifact artifact_category mandatory_artifact?] artifact_dependencies] input']} + (when (do ! + [data (try.of_maybe (dictionary.value (format (%.nat @artifact) extension) actual)) + .let [context [@module @artifact] + declaration (at host ingest context data)]] + (when artifact_category + {category.#Anonymous} + (do ! + [.let [output (sequence.suffix [@artifact {.#None} data] output)] + _ (at host re_learn context {.#None} declaration)] + (in [definitions + output])) + + {category.#Definition [name function_artifact]} + (let [output (sequence.suffix [@artifact {.#None} data] output)] + (if (text#= $/program.name name) + (in [definitions + output]) + (do ! + [value (at host re_load context {.#None} declaration)] + (in [(dictionary.has name value definitions) + output])))) - {category.#Custom name} - (do ! - [.let [output (sequence.suffix [@artifact {.#Some name} data] output)] - _ (at host re_learn context {.#Some name} declaration)] - (in [definitions - [analysers - synthesizers - translators - declarations] - output])))) - {try.#Success [definitions' bundles' output']} - (again input' definitions' bundles' output') + {category.#Custom name} + (do ! + [.let [output (sequence.suffix [@artifact {.#Some name} data] output)] + _ (at host re_learn context {.#Some name} declaration)] + (in [definitions + output])))) + {try.#Success [definitions' output']} + (again input' definitions' output') - failure - failure) - - {.#End} - {try.#Success [definitions bundles output]})))) + failure + failure) + + {.#End} + {try.#Success [definitions output]}))) content (document.content $.key document) definitions (monad.each ! (function (_ [def_name [exported? def_global]]) (when def_global @@ -238,24 +160,23 @@ (in (list)))) (the .#definitions content))] (in [(document.document $.key (has .#definitions (list#conjoint definitions) content)) - bundles]))) + output]))) (def (load_definitions fs context @module host_environment entry) (All (_ expression declaration) (-> (file.System Async) Context module.ID (translation.Host expression declaration) (archive.Entry .Module) - (Async (Try [(archive.Entry .Module) Bundles])))) + (Async (Try (archive.Entry .Module))))) (do (try.with async.monad) [actual (is (Async (Try (Dictionary Text Binary))) (cache/module.artifacts async.monad fs context @module)) .let [expected (registry.artifacts (the archive.#registry entry))] - [document bundles output] (|> (the [archive.#module module.#document] entry) - (loaded_document (the context.#artifact_extension context) host_environment @module expected actual) - async#in)] - (in [(|> entry - (has [archive.#module module.#document] document) - (has archive.#output output)) - bundles]))) + [document output] (|> (the [archive.#module module.#document] entry) + (loaded_document (the context.#artifact_extension context) host_environment @module expected actual) + async#in)] + (in (|> entry + (has [archive.#module module.#document] document) + (has archive.#output output))))) (def pseudo_module Text @@ -319,20 +240,19 @@ (All (_ expression declaration) (-> (translation.Host expression declaration) (file.System Async) Context Purge (dependency.Order .Module) - (Async (Try (List [[descriptor.Module (archive.Entry .Module)] Bundles]))))) + (Async (Try (List [descriptor.Module (archive.Entry .Module)]))))) (do [! (try.with async.monad)] [... TODO: Stop needing to wrap this expression in an unnecessary "do" expression. it (|> load_order (list.only (|>> product.left (dictionary.key? purge) not)) (monad.each ! (function (_ [module_name [@module entry]]) (do ! - [[entry bundles] (with_expansions [ (..load_definitions fs context @module host_environment entry)] - (for @.old (as (Async (Try [(archive.Entry .Module) Bundles])) - ) - ))] - (in (with_expansions [ [[module_name entry] - bundles]] - (for @.old (as [[descriptor.Module (archive.Entry .Module)] Bundles] + [entry (with_expansions [ (..load_definitions fs context @module host_environment entry)] + (for @.old (as (Async (Try (archive.Entry .Module))) + ) + ))] + (in (with_expansions [ [module_name entry]] + (for @.old (as [descriptor.Module (archive.Entry .Module)] ) )))))))] (in it))) @@ -340,7 +260,7 @@ (def (load_every_reserved_module customs configuration host_environment fs context import contexts archive) (All (_ expression declaration) (-> (List Custom) Configuration (translation.Host expression declaration) (file.System Async) Context Import (List //.Context) Archive - (Async (Try [Archive .Lux Bundles])))) + (Async (Try [Archive .Lux])))) (do [! (try.with async.monad)] [pre_loaded_caches (..pre_loaded_caches customs fs context import contexts archive) load_order (async#in (load_order archive pre_loaded_caches)) @@ -352,26 +272,17 @@ (async#in (do [! try.monad] [archive (monad.mix ! - (function (_ [[module entry] _bundle] archive) + (function (_ [module entry] archive) (archive.has module entry archive)) archive loaded_caches) analysis_state (..analysis_state (the context.#host context) configuration archive)] - (in [archive - analysis_state - (list#mix (function (_ [_ [+analysers +synthesizers +translators +declarations]] - [analysers synthesizers translators declarations]) - [(dictionary.composite +analysers analysers) - (dictionary.composite +synthesizers synthesizers) - (dictionary.composite +translators translators) - (dictionary.composite +declarations declarations)]) - ..empty_bundles - loaded_caches)]))))) + (in [archive analysis_state]))))) (def .public (thaw customs configuration host_environment fs context import contexts) (All (_ expression declaration) (-> (List Custom) Configuration (translation.Host expression declaration) (file.System Async) Context Import (List //.Context) - (Async (Try [Archive .Lux Bundles])))) + (Async (Try [Archive .Lux])))) (do async.monad [binary (at fs read (cache/archive.descriptor fs context))] (when binary @@ -382,5 +293,4 @@ {try.#Failure error} (in {try.#Success [archive.empty - (fresh_analysis_state (the context.#host context) configuration) - ..empty_bundles]})))) + (fresh_analysis_state (the context.#host context) configuration)]})))) diff --git a/stdlib/source/library/lux/world/file/extension.lux b/stdlib/source/library/lux/world/file/extension.lux new file mode 100644 index 000000000..12b6700be --- /dev/null +++ b/stdlib/source/library/lux/world/file/extension.lux @@ -0,0 +1,108 @@ +... https://en.wikipedia.org/wiki/List_of_filename_extensions +(.require + [library + [lux (.except) + [data + [text + ["%" \\format]]] + [meta + [macro + ["[0]" template]]]]]) + +(def .public Extension + Text) + +(with_template [ ] + [(def .public + Extension + (%.format "." )) + + (`` (with_template [] + [(def .public )] + + (,, (template.spliced )) + )) + ] + + ... https://en.wikipedia.org/wiki/List_of_filename_extensions_(0%E2%80%939) + ["7z" compressed_7z_archive []] + + ... https://en.wikipedia.org/wiki/List_of_filename_extensions_(A%E2%80%93E) + ["a" archive []] + ["aac" advanced_audio_coding []] + ["agda" agda_source_code []] + ["apk" android_application_package []] + ["asm" assembler_source_code []] + + ["bin" binary []] + ["bz2" bzip2_archive []] + ["blend" blender_project []] + + ["c" c_source_code [[c]]] + ["cpp" c++_source_code [[c++]]] + ["class" java_class []] + ["com" dos_program []] + ["cs" c#_source_code []] + ["css" css []] + ["csv" comma_separated_values [[csv]]] + + ["d" d_source_code []] + ["dart" dart_source_code []] + + ["el" emacs_lisp_source_code [[emacs_lisp]]] + ["elc" compiled_emacs_lisp_code []] + ["elf" executable_and_linkable_file []] + ["epub" electronic_publication []] + ["erl" erlang_source_code [[erlang]]] + ["exe" executable_program []] + + ... https://en.wikipedia.org/wiki/List_of_filename_extensions_(F%E2%80%93L) + ["flame" apophysis_fractal []] + + ["gpx" gps_exchange_format []] + ["gz" gzip_compressed_data []] + + ["har" http_archive_format []] + ["h" c_header []] + ["html" html []] + + ["iso" optical_disc_file_system []] + + ["jar" java_archive [[jar]]] + ["java" java_source_code [[java]]] + ["js" javascript_source_code [[javascript] [js]]] + ["json" javascript_object_notation [[json]]] + + ["ll" llvm_assembly []] + ["lua" lua_source_code [[lua]]] + ["lz" lzip_archive []] + + ... https://en.wikipedia.org/wiki/List_of_filename_extensions_(M%E2%80%93R) + ["md" markdown []] + ["mid" musical_instrument_digital_interface [[midi]]] + + ["o" object_code []] + ["ogg" vorbis_audio [[ogg]]] + + ["pdf" portable_document_format [[pdf]]] + ["php" php_source_code [[php]]] + ["pom" maven_build_configuration []] + ["ps" postscript_source_code []] + ["py" python_source_code [[python]]] + + ["rb" ruby_source_code [[ruby]]] + + ... https://en.wikipedia.org/wiki/List_of_filename_extensions_(S%E2%80%93Z) + ["scm" scheme_source_code [[scheme]]] + ["sh" unix_shell_script []] + ["sql" structured_query_language [[sql]]] + ["svg" scalable_vector_graphics [[svg]]] + + ["tar" tape_archive [[tar]]] + ["tmp" temporary_file []] + ["tsv" tab_separated_values []] + + ["yaml" yaml [[yet_another_markup_language] [yaml_ain't_markup_language]]] + + ["zip" zip_archive [[zip]]] + ) diff --git a/stdlib/source/specification/lux/abstract/order.lux b/stdlib/source/specification/lux/abstract/order.lux index ae7dc3355..1bf62b3cc 100644 --- a/stdlib/source/specification/lux/abstract/order.lux +++ b/stdlib/source/specification/lux/abstract/order.lux @@ -3,57 +3,68 @@ [lux (.except) [abstract [monad (.only do)]] + [data + ["[0]" bit (.use "[1]#[0]" equivalence)]] [math ["[0]" random (.only Random)]] [test ["_" property (.only Test)]]]] [\\library - ["[0]" /]]) + ["[0]" /]] + [// + ["[0]S" equivalence]]) -(def .public (spec (open "@//[0]") generator) - (All (_ a) (-> (/.Order a) (Random a) Test)) +(def .public (spec (open "/#[0]") random) + (All (_ of) + (-> (/.Order of) (Random of) + Test)) (<| (_.for [/.Order]) (all _.and + (_.for [/.equivalence] + (equivalenceS.spec /#equivalence random)) + (do random.monad - [parameter generator - subject generator] - (_.test "Values are either ordered, or they are equal. All options(_ are mutually exclusive." - (cond (@//< parameter subject) - (not (or (@//< subject parameter) - (@//= parameter subject))) + [parameter random + subject random + .let [equal_or_ordered! + (let [equal! + (/#= parameter subject) - (@//< subject parameter) - (not (@//= parameter subject)) + ordered! + (or (and (/#< parameter subject) + (not (/#< subject parameter))) + (and (/#< subject parameter) + (not (/#< parameter subject))))] + (bit#= equal! (not ordered!)))] - ... else - (@//= parameter subject)))) - (do random.monad - [parameter generator - subject (random.only (|>> (@//= parameter) not) - generator) + subject (random.only (|>> (/#= parameter) not) + random) extra (random.only (function (_ value) - (not (or (@//= parameter value) - (@//= subject value)))) - generator)] - (_.test "Transitive property." - (if (@//< parameter subject) - (let [greater? (and (@//< subject extra) - (@//< parameter extra)) - lesser? (and (@//< extra parameter) - (@//< extra subject)) - in_between? (and (@//< parameter extra) - (@//< extra subject))] - (or greater? - lesser? - in_between?)) - ... (@//< subject parameter) - (let [greater? (and (@//< extra subject) - (@//< extra parameter)) - lesser? (and (@//< parameter extra) - (@//< subject extra)) - in_between? (and (@//< subject extra) - (@//< extra parameter))] - (or greater? - lesser? - in_between?))))) + (not (or (/#= parameter value) + (/#= subject value)))) + random) + .let [transitive_property! + (if (/#< parameter subject) + (let [greater? (and (/#< subject extra) + (/#< parameter extra)) + lesser? (and (/#< extra parameter) + (/#< extra subject)) + in_between? (and (/#< parameter extra) + (/#< extra subject))] + (or greater? + lesser? + in_between?)) + ... (/#< subject parameter) + (let [greater? (and (/#< extra subject) + (/#< extra parameter)) + lesser? (and (/#< parameter extra) + (/#< subject extra)) + in_between? (and (/#< subject extra) + (/#< extra parameter))] + (or greater? + lesser? + in_between?)))]] + (_.coverage [/.<] + (and equal_or_ordered! + transitive_property!))) ))) diff --git a/stdlib/source/specification/lux/math/arithmetic.lux b/stdlib/source/specification/lux/math/arithmetic.lux new file mode 100644 index 000000000..7ae9f3f06 --- /dev/null +++ b/stdlib/source/specification/lux/math/arithmetic.lux @@ -0,0 +1,46 @@ +(.require + [library + [lux (.except) + [abstract + [equivalence (.only Equivalence)] + [monad (.only do)]] + [math + ["[0]" random (.only Random)]] + [test + ["_" property (.only Test)]]]] + [\\library + ["[0]" /]]) + +(def .public (spec (open "[0]") (open "[0]") random) + (All (_ of) + (-> (Equivalence of) (/.Arithmetic of) (Random of) + Test)) + (do random.monad + [any random + .let [zero (- any any) + non_zero (random.only (|>> (= zero) not) + random)] + left non_zero + right non_zero + .let [one (/ right right)]] + (<| (_.covering /._) + (_.for [/.Arithmetic]) + (all _.and + (_.coverage [/.+ /.-] + (and (|> left (+ right) (- right) (= left)) + (|> left (- right) (+ right) (= left)) + (|> left (+ zero) (= left)) + (|> left (- zero) (= left)) + (|> left (- left) (= zero)))) + (_.coverage [/.* /./] + (and (|> left (* right) (/ right) (= left)) + (|> left (* one) (= left)) + (|> left (/ one) (= left)) + (|> left (/ left) (= one)) + (|> left (* zero) (= zero)))) + (_.coverage [/.%] + (let [rem (% left right) + div (|> right (- rem) (/ left))] + (= right + (|> div (* left) (+ rem))))) + )))) diff --git a/stdlib/source/test/lux/math/number/complex.lux b/stdlib/source/test/lux/math/number/complex.lux index 2b8eada59..18fbdd28e 100644 --- a/stdlib/source/test/lux/math/number/complex.lux +++ b/stdlib/source/test/lux/math/number/complex.lux @@ -9,7 +9,9 @@ [collection ["[0]" list (.use "[1]#[0]" functor)]]] [math - ["[0]" random (.only Random)]] + ["[0]" random (.only Random)] + ["[0]" arithmetic + ["[1]S" \\specification]]] [test ["_" property (.only Test)]]]] [\\library @@ -272,6 +274,8 @@ (all _.and (_.for [/.= /.equivalence] ($equivalence.spec /.equivalence ..random)) + (_.for [/.arithmetic] + (arithmeticS.spec /.equivalence /.arithmetic ..random)) ..construction ..constant diff --git a/stdlib/source/test/lux/math/number/frac.lux b/stdlib/source/test/lux/math/number/frac.lux index 9d6844441..673b04276 100644 --- a/stdlib/source/test/lux/math/number/frac.lux +++ b/stdlib/source/test/lux/math/number/frac.lux @@ -13,7 +13,9 @@ [data ["[0]" bit (.use "[1]#[0]" equivalence)]] [math - ["[0]" random (.only Random)]] + ["[0]" random (.only Random)] + ["[0]" arithmetic + ["[1]S" \\specification]]] [meta ["@" target] [macro @@ -120,6 +122,8 @@ [/.binary] [/.octal] [/.decimal] [/.hex] )) + (_.for [/.arithmetic] + (arithmeticS.spec /.equivalence /.arithmetic random.safe_frac)) ))) (with_expansions [ (these (ffi.import java/lang/Double diff --git a/stdlib/source/test/lux/math/number/int.lux b/stdlib/source/test/lux/math/number/int.lux index afb733787..46c2739e3 100644 --- a/stdlib/source/test/lux/math/number/int.lux +++ b/stdlib/source/test/lux/math/number/int.lux @@ -14,7 +14,9 @@ [data ["[0]" bit (.use "[1]#[0]" equivalence)]] [math - ["[0]" random (.only Random)]] + ["[0]" random (.only Random)] + ["[0]" arithmetic + ["[1]S" \\specification]]] [test ["_" property (.only Test)]]]] [\\library @@ -53,6 +55,8 @@ [/.binary] [/.octal] [/.decimal] [/.hex] )) + (_.for [/.arithmetic] + (arithmeticS.spec /.equivalence /.arithmetic random.int)) ))) (def predicate diff --git a/stdlib/source/test/lux/math/number/nat.lux b/stdlib/source/test/lux/math/number/nat.lux index 9ab7e63fb..aecbccf81 100644 --- a/stdlib/source/test/lux/math/number/nat.lux +++ b/stdlib/source/test/lux/math/number/nat.lux @@ -14,7 +14,9 @@ [data ["[0]" bit (.use "[1]#[0]" equivalence)]] [math - ["[0]" random]] + ["[0]" random] + ["[0]" arithmetic + ["[1]S" \\specification]]] [test ["_" property (.only Test)]]]] [\\library @@ -51,6 +53,8 @@ [/.binary] [/.octal] [/.decimal] [/.hex] )) + (_.for [/.arithmetic] + (arithmeticS.spec /.equivalence /.arithmetic random.nat)) ))) (def predicate diff --git a/stdlib/source/test/lux/math/number/ratio.lux b/stdlib/source/test/lux/math/number/ratio.lux index 74c9a9ca7..d5062806c 100644 --- a/stdlib/source/test/lux/math/number/ratio.lux +++ b/stdlib/source/test/lux/math/number/ratio.lux @@ -13,7 +13,9 @@ [data ["[0]" bit (.use "[1]#[0]" equivalence)]] [math - ["[0]" random (.only Random)]] + ["[0]" random (.only Random)] + ["[0]" arithmetic + ["[1]S" \\specification]]] [test ["_" property (.only Test)]]]] [\\library @@ -53,6 +55,8 @@ )) (_.for [/.codec] ($codec.spec /.equivalence /.codec ..random)) + (_.for [/.arithmetic] + (arithmeticS.spec /.equivalence /.arithmetic ..random)) (do random.monad [.let [(open "#[0]") /.equivalence] diff --git a/stdlib/source/test/lux/math/number/rev.lux b/stdlib/source/test/lux/math/number/rev.lux index 6f5d6a4eb..724d0112a 100644 --- a/stdlib/source/test/lux/math/number/rev.lux +++ b/stdlib/source/test/lux/math/number/rev.lux @@ -14,7 +14,9 @@ [data ["[0]" bit (.use "[1]#[0]" equivalence)]] [math - ["[0]" random]] + ["[0]" random] + ["[0]" arithmetic + ["[1]S" \\specification]]] [test ["_" property (.only Test)]]]] [\\library @@ -52,6 +54,8 @@ [/.binary] [/.octal] [/.decimal] [/.hex] )) + (_.for [/.arithmetic] + (arithmeticS.spec /.equivalence /.arithmetic random.rev)) ))) (def .public test diff --git a/stdlib/source/test/lux/world/file.lux b/stdlib/source/test/lux/world/file.lux index 35402d81a..d2f3cde55 100644 --- a/stdlib/source/test/lux/world/file.lux +++ b/stdlib/source/test/lux/world/file.lux @@ -28,7 +28,8 @@ ["[0]" unit] ["_" property (.only Test)]]]] ["[0]" / - ["[1][0]" watch]] + ["[1][0]" watch] + ["[1][0]" extension]] [\\library ["[0]" /]] [\\specification @@ -288,4 +289,5 @@ false)))) /watch.test + /extension.test )))) diff --git a/stdlib/source/test/lux/world/file/extension.lux b/stdlib/source/test/lux/world/file/extension.lux new file mode 100644 index 000000000..428933939 --- /dev/null +++ b/stdlib/source/test/lux/world/file/extension.lux @@ -0,0 +1,148 @@ +(.require + [library + [lux (.except) + [abstract + [monad (.only do)]] + [data + ["[0]" text] + [collection + ["[0]" list] + ["[0]" set]]] + [math + ["[0]" random (.only Random)] + [number + ["n" nat]]] + [meta + [macro + ["[0]" template]]] + [test + ["_" property (.only Test)]]]] + [\\library + ["[0]" /]]) + +(with_expansions [ (these [/.compressed_7z_archive] + + [/.archive] + [/.advanced_audio_coding] + [/.agda_source_code] + [/.android_application_package] + [/.assembler_source_code] + + [/.binary] + [/.bzip2_archive] + [/.blender_project] + + [/.c_source_code] + [/.c++_source_code] + [/.java_class] + [/.dos_program] + [/.c#_source_code] + [/.css] + [/.comma_separated_values] + + [/.d_source_code] + [/.dart_source_code] + + [/.emacs_lisp_source_code] + [/.compiled_emacs_lisp_code] + [/.executable_and_linkable_file] + [/.electronic_publication] + [/.erlang_source_code] + [/.executable_program] + + [/.apophysis_fractal] + + [/.gps_exchange_format] + [/.gzip_compressed_data] + + [/.http_archive_format] + [/.c_header] + [/.html] + + [/.optical_disc_file_system] + + [/.java_archive] + [/.java_source_code] + [/.javascript_source_code] + [/.javascript_object_notation] + + [/.llvm_assembly] + [/.lua_source_code] + [/.lzip_archive] + + [/.markdown] + [/.musical_instrument_digital_interface] + + [/.object_code] + [/.vorbis_audio] + + [/.portable_document_format] + [/.php_source_code] + [/.maven_build_configuration] + [/.postscript_source_code] + [/.python_source_code] + + [/.ruby_source_code] + + [/.scheme_source_code] + [/.unix_shell_script] + [/.structured_query_language] + [/.scalable_vector_graphics] + + [/.tape_archive] + [/.temporary_file] + [/.tab_separated_values] + + [/.yaml] + + [/.zip_archive])] + (def .public test + Test + (<| (_.covering /._) + (do [! random.monad] + []) + (_.for [/.Extension]) + (`` (all _.and + (_.coverage [(,, (with_template [] + [] + + ))] + (let [options (list ) + uniques (set.of_list text.hash options)] + (n.= (list.size options) + (set.size uniques)))) + (,, (with_template [ ] + [(with_expansions [' (template.spliced )] + (`` (_.coverage [(,, (with_template [] + [] + + '))] + (and (,, (with_template [] + [(same? )] + + '))))))] + + [/.c_source_code [[/.c]]] + [/.c++_source_code [[/.c++]]] + [/.comma_separated_values [[/.csv]]] + [/.emacs_lisp_source_code [[/.emacs_lisp]]] + [/.erlang_source_code [[/.erlang]]] + [/.java_archive [[/.jar]]] + [/.java_source_code [[/.java]]] + [/.javascript_source_code [[/.javascript] [/.js]]] + [/.javascript_object_notation [[/.json]]] + [/.lua_source_code [[/.lua]]] + [/.musical_instrument_digital_interface [[/.midi]]] + [/.vorbis_audio [[/.ogg]]] + [/.portable_document_format [[/.pdf]]] + [/.php_source_code [[/.php]]] + [/.python_source_code [[/.python]]] + [/.ruby_source_code [[/.ruby]]] + [/.scheme_source_code [[/.scheme]]] + [/.structured_query_language [[/.sql]]] + [/.scalable_vector_graphics [[/.svg]]] + [/.tape_archive [[/.tar]]] + [/.yaml [[/.yet_another_markup_language] [/.yaml_ain't_markup_language]]] + [/.zip_archive [[/.zip]]] + )) + ))))) -- cgit v1.2.3