diff options
| author | Eduardo Julian | 2017-01-25 07:02:33 -0400 |
|---|---|---|
| committer | Eduardo Julian | 2017-01-25 07:02:33 -0400 |
| commit | f8c2389db4a9b3239b00b9d209237d5116e12e3c (patch) | |
| tree | 7144c34363b804b91f3591f726cf2f4d944873c1 | |
| parent | 5b7b661ff721327d33b7078f4d07f6fe93307ee0 (diff) | |
- Renamed lux/data/struct/tree to lux/data/struct/tree/rose.
- Moved lux/data/struct/zipper to lux/data/struct/tree/zipper.
- Moved lux/regex to lux/lexer/regex.
- Changed the suffix of annotation tags, from M to A.
- Renamed Frac(tional) numbers to Deg(rees).
48 files changed, 592 insertions, 585 deletions
diff --git a/lux-mode/lux-mode.el b/lux-mode/lux-mode.el index d471370bf..40980f097 100644 --- a/lux-mode/lux-mode.el +++ b/lux-mode/lux-mode.el @@ -248,7 +248,7 @@ Called by `imenu--generic-function'." ("\\<\\+\\(0\\|[1-9][0-9_]*\\)\\>" 0 font-lock-constant-face) ; Int|Real literals ("\\<-?\\(0\\|[1-9][0-9_]*\\)\\(\\.[0-9_]+\\)?\\>" 0 font-lock-constant-face) - ; Frac literals + ; Deg literals ("\\<\\(\\.[0-9_]+\\)\\>" 0 font-lock-constant-face) ; Tags ("#;[a-zA-Z0-9-\\+_=!@\\$%\\^&\\*<>\.,/\\\\\\|':~\\?]+" 0 font-lock-type-face) diff --git a/luxc/src/lux.clj b/luxc/src/lux.clj index c1e04b9a3..d17f1640d 100644 --- a/luxc/src/lux.clj +++ b/luxc/src/lux.clj @@ -15,7 +15,7 @@ (def unit-separator (str (char 31))) -(defn ^:private process-dirs +(defn ^:private separate-paths "(-> Text (List Text))" [resources-dirs] (-> resources-dirs @@ -26,14 +26,14 @@ (defn -main [& args] (|case (&/->list args) (&/$Cons "release" (&/$Cons program-module (&/$Cons resources-dirs (&/$Cons source-dirs (&/$Cons target-dir (&/$Nil)))))) - (time (&compiler/compile-program &/$Release program-module (process-dirs resources-dirs) (process-dirs source-dirs) target-dir)) + (time (&compiler/compile-program &/$Release program-module (separate-paths resources-dirs) (separate-paths source-dirs) target-dir)) (&/$Cons "debug" (&/$Cons program-module (&/$Cons resources-dirs (&/$Cons source-dirs (&/$Cons target-dir (&/$Nil)))))) - (time (&compiler/compile-program &/$Debug program-module (process-dirs resources-dirs) (process-dirs source-dirs) target-dir)) + (time (&compiler/compile-program &/$Debug program-module (separate-paths resources-dirs) (separate-paths source-dirs) target-dir)) (&/$Cons "repl" (&/$Cons resources-dirs (&/$Cons source-dirs (&/$Cons target-dir (&/$Nil))))) - (&repl/repl (process-dirs resources-dirs) - (process-dirs source-dirs) + (&repl/repl (separate-paths resources-dirs) + (separate-paths source-dirs) target-dir) _ diff --git a/luxc/src/lux/analyser.clj b/luxc/src/lux/analyser.clj index eefa5ee3d..f47bcf914 100644 --- a/luxc/src/lux/analyser.clj +++ b/luxc/src/lux/analyser.clj @@ -79,9 +79,9 @@ (|do [_ (&type/check exo-type &type/Int)] (return (&/|list (&&/|meta exo-type cursor (&&/$int ?value))))) - (&/$FracS ?value) - (|do [_ (&type/check exo-type &type/Frac)] - (return (&/|list (&&/|meta exo-type cursor (&&/$frac ?value))))) + (&/$DegS ?value) + (|do [_ (&type/check exo-type &type/Deg)] + (return (&/|list (&&/|meta exo-type cursor (&&/$deg ?value))))) (&/$RealS ?value) (|do [_ (&type/check exo-type &type/Real)] diff --git a/luxc/src/lux/analyser/base.clj b/luxc/src/lux/analyser/base.clj index 9bdcdeb11..ccc7260bc 100644 --- a/luxc/src/lux/analyser/base.clj +++ b/luxc/src/lux/analyser/base.clj @@ -14,7 +14,7 @@ ("bool" 1) ("nat" 1) ("int" 1) - ("frac" 1) + ("deg" 1) ("real" 1) ("char" 1) ("text" 1) diff --git a/luxc/src/lux/analyser/case.clj b/luxc/src/lux/analyser/case.clj index a5c37ba6b..042ca8352 100644 --- a/luxc/src/lux/analyser/case.clj +++ b/luxc/src/lux/analyser/case.clj @@ -20,7 +20,7 @@ ("BoolTotal" 2) ("NatTotal" 2) ("IntTotal" 2) - ("FracTotal" 2) + ("DegTotal" 2) ("RealTotal" 2) ("CharTotal" 2) ("TextTotal" 2) @@ -33,7 +33,7 @@ ("BoolTestAC" 1) ("NatTestAC" 1) ("IntTestAC" 1) - ("FracTestAC" 1) + ("DegTestAC" 1) ("RealTestAC" 1) ("CharTestAC" 1) ("TextTestAC" 1) @@ -291,10 +291,10 @@ =kont kont] (return (&/T [($IntTestAC ?value) =kont]))) - (&/$FracS ?value) - (|do [_ (&type/check value-type &type/Frac) + (&/$DegS ?value) + (|do [_ (&type/check value-type &type/Deg) =kont kont] - (return (&/T [($FracTestAC ?value) =kont]))) + (return (&/T [($DegTestAC ?value) =kont]))) (&/$RealS ?value) (|do [_ (&type/check value-type &type/Real) @@ -426,8 +426,8 @@ [($IntTotal total? ?values) ($NoTestAC)] (return ($IntTotal true ?values)) - [($FracTotal total? ?values) ($NoTestAC)] - (return ($FracTotal true ?values)) + [($DegTotal total? ?values) ($NoTestAC)] + (return ($DegTotal true ?values)) [($RealTotal total? ?values) ($NoTestAC)] (return ($RealTotal true ?values)) @@ -456,8 +456,8 @@ [($IntTotal total? ?values) ($StoreTestAC ?idx)] (return ($IntTotal true ?values)) - [($FracTotal total? ?values) ($StoreTestAC ?idx)] - (return ($FracTotal true ?values)) + [($DegTotal total? ?values) ($StoreTestAC ?idx)] + (return ($DegTotal true ?values)) [($RealTotal total? ?values) ($StoreTestAC ?idx)] (return ($RealTotal true ?values)) @@ -492,11 +492,11 @@ [($IntTotal total? ?values) ($IntTestAC ?value)] (return ($IntTotal total? (&/$Cons ?value ?values))) - [($DefaultTotal total?) ($FracTestAC ?value)] - (return ($FracTotal total? (&/|list ?value))) + [($DefaultTotal total?) ($DegTestAC ?value)] + (return ($DegTotal total? (&/|list ?value))) - [($FracTotal total? ?values) ($FracTestAC ?value)] - (return ($FracTotal total? (&/$Cons ?value ?values))) + [($DegTotal total? ?values) ($DegTestAC ?value)] + (return ($DegTotal total? (&/$Cons ?value ?values))) [($DefaultTotal total?) ($RealTestAC ?value)] (return ($RealTotal total? (&/|list ?value))) @@ -585,8 +585,8 @@ (|do [_ (&type/check value-type &type/Int)] (return ?total)) - ($FracTotal ?total _) - (|do [_ (&type/check value-type &type/Frac)] + ($DegTotal ?total _) + (|do [_ (&type/check value-type &type/Deg)] (return ?total)) ($RealTotal ?total _) diff --git a/luxc/src/lux/analyser/host.clj b/luxc/src/lux/analyser/host.clj index 977a7b1fe..8c6b1ac80 100644 --- a/luxc/src/lux/analyser/host.clj +++ b/luxc/src/lux/analyser/host.clj @@ -1074,23 +1074,23 @@ ^:private analyse-nat-eq ["nat" "="] &type/Nat &type/Bool ^:private analyse-nat-lt ["nat" "<"] &type/Nat &type/Bool - ^:private analyse-frac-add ["frac" "+"] &type/Frac &type/Frac - ^:private analyse-frac-sub ["frac" "-"] &type/Frac &type/Frac - ^:private analyse-frac-mul ["frac" "*"] &type/Frac &type/Frac - ^:private analyse-frac-div ["frac" "/"] &type/Frac &type/Frac - ^:private analyse-frac-rem ["frac" "%"] &type/Frac &type/Frac - ^:private analyse-frac-eq ["frac" "="] &type/Frac &type/Bool - ^:private analyse-frac-lt ["frac" "<"] &type/Frac &type/Bool + ^:private analyse-deg-add ["deg" "+"] &type/Deg &type/Deg + ^:private analyse-deg-sub ["deg" "-"] &type/Deg &type/Deg + ^:private analyse-deg-mul ["deg" "*"] &type/Deg &type/Deg + ^:private analyse-deg-div ["deg" "/"] &type/Deg &type/Deg + ^:private analyse-deg-rem ["deg" "%"] &type/Deg &type/Deg + ^:private analyse-deg-eq ["deg" "="] &type/Deg &type/Bool + ^:private analyse-deg-lt ["deg" "<"] &type/Deg &type/Bool ) -(defn ^:private analyse-frac-scale [analyse exo-type ?values] +(defn ^:private analyse-deg-scale [analyse exo-type ?values] (|do [:let [(&/$Cons x (&/$Cons y (&/$Nil))) ?values] - =x (&&/analyse-1 analyse &type/Frac x) + =x (&&/analyse-1 analyse &type/Deg x) =y (&&/analyse-1 analyse &type/Nat y) - _ (&type/check exo-type &type/Frac) + _ (&type/check exo-type &type/Deg) _cursor &/cursor] - (return (&/|list (&&/|meta &type/Frac _cursor - (&&/$proc (&/T ["frac" "scale"]) (&/|list =x =y) (&/|list))))))) + (return (&/|list (&&/|meta &type/Deg _cursor + (&&/$proc (&/T ["deg" "scale"]) (&/|list =x =y) (&/|list))))))) (do-template [<encode> <encode-op> <decode> <decode-op> <type>] (do (defn <encode> [analyse exo-type ?values] @@ -1111,7 +1111,7 @@ (&&/$proc (&/T <decode-op>) (&/|list =x) (&/|list))))))))) ^:private analyse-nat-encode ["nat" "encode"] ^:private analyse-nat-decode ["nat" "decode"] &type/Nat - ^:private analyse-frac-encode ["frac" "encode"] ^:private analyse-frac-decode ["frac" "decode"] &type/Frac + ^:private analyse-deg-encode ["deg" "encode"] ^:private analyse-deg-decode ["deg" "decode"] &type/Deg ) (do-template [<name> <type> <op>] @@ -1125,8 +1125,8 @@ ^:private analyse-nat-min-value &type/Nat ["nat" "min-value"] ^:private analyse-nat-max-value &type/Nat ["nat" "max-value"] - ^:private analyse-frac-min-value &type/Frac ["frac" "min-value"] - ^:private analyse-frac-max-value &type/Frac ["frac" "max-value"] + ^:private analyse-deg-min-value &type/Deg ["deg" "min-value"] + ^:private analyse-deg-max-value &type/Deg ["deg" "max-value"] ) (do-template [<name> <from-type> <to-type> <op>] @@ -1143,8 +1143,8 @@ ^:private analyse-int-to-nat &type/Int &type/Nat ["int" "to-nat"] ^:private analyse-char-to-nat &type/Char &type/Nat ["char" "to-nat"] - ^:private analyse-frac-to-real &type/Frac &type/Real ["frac" "to-real"] - ^:private analyse-real-to-frac &type/Real &type/Frac ["real" "to-frac"] + ^:private analyse-deg-to-real &type/Deg &type/Real ["deg" "to-real"] + ^:private analyse-real-to-deg &type/Real &type/Deg ["real" "to-deg"] ) (defn analyse-host [analyse exo-type compilers category proc ?values] @@ -1189,21 +1189,21 @@ "to-char" (analyse-nat-to-char analyse exo-type ?values) ) - "frac" + "deg" (case proc - "+" (analyse-frac-add analyse exo-type ?values) - "-" (analyse-frac-sub analyse exo-type ?values) - "*" (analyse-frac-mul analyse exo-type ?values) - "/" (analyse-frac-div analyse exo-type ?values) - "%" (analyse-frac-rem analyse exo-type ?values) - "=" (analyse-frac-eq analyse exo-type ?values) - "<" (analyse-frac-lt analyse exo-type ?values) - "encode" (analyse-frac-encode analyse exo-type ?values) - "decode" (analyse-frac-decode analyse exo-type ?values) - "min-value" (analyse-frac-min-value analyse exo-type ?values) - "max-value" (analyse-frac-max-value analyse exo-type ?values) - "to-real" (analyse-frac-to-real analyse exo-type ?values) - "scale" (analyse-frac-scale analyse exo-type ?values) + "+" (analyse-deg-add analyse exo-type ?values) + "-" (analyse-deg-sub analyse exo-type ?values) + "*" (analyse-deg-mul analyse exo-type ?values) + "/" (analyse-deg-div analyse exo-type ?values) + "%" (analyse-deg-rem analyse exo-type ?values) + "=" (analyse-deg-eq analyse exo-type ?values) + "<" (analyse-deg-lt analyse exo-type ?values) + "encode" (analyse-deg-encode analyse exo-type ?values) + "decode" (analyse-deg-decode analyse exo-type ?values) + "min-value" (analyse-deg-min-value analyse exo-type ?values) + "max-value" (analyse-deg-max-value analyse exo-type ?values) + "to-real" (analyse-deg-to-real analyse exo-type ?values) + "scale" (analyse-deg-scale analyse exo-type ?values) ) "int" @@ -1213,7 +1213,7 @@ "real" (case proc - "to-frac" (analyse-real-to-frac analyse exo-type ?values) + "to-deg" (analyse-real-to-deg analyse exo-type ?values) ) "char" diff --git a/luxc/src/lux/analyser/module.clj b/luxc/src/lux/analyser/module.clj index 62948bf0d..272f37e64 100644 --- a/luxc/src/lux/analyser/module.clj +++ b/luxc/src/lux/analyser/module.clj @@ -204,14 +204,14 @@ (|let [[?type ?meta ?value] $def] (if (.equals ^Object current-module module) (|case (&meta/meta-get &meta/alias-tag ?meta) - (&/$Some (&/$IdentM [?r-module ?r-name])) + (&/$Some (&/$IdentA [?r-module ?r-name])) ((find-def ?r-module ?r-name) state) _ (return* state (&/T [(&/T [module name]) $def]))) (|case (&meta/meta-get &meta/export?-tag ?meta) - (&/$Some (&/$BoolM true)) + (&/$Some (&/$BoolA true)) (return* state (&/T [(&/T [module name]) $def])) _ @@ -364,7 +364,7 @@ (|let [[k _def-data] kv [_ ?def-meta _] _def-data] (|case (&meta/meta-get &meta/alias-tag ?def-meta) - (&/$Some (&/$IdentM [?r-module ?r-name])) + (&/$Some (&/$IdentA [?r-module ?r-name])) (&/T [k (str ?r-module ";" ?r-name) _def-data]) _ @@ -374,7 +374,7 @@ (do-template [<name> <type> <tag> <desc>] (defn <name> [module name meta type] (|case (&meta/meta-get <tag> meta) - (&/$Some (&/$BoolM true)) + (&/$Some (&/$BoolA true)) (&/try-all% (&/|list (&type/check <type> type) (&/fail-with-loc (str "[Analyser Error] Can't tag as lux;" <desc> "? if it's not a " <desc> ": " (str module ";" name))))) @@ -387,11 +387,11 @@ (defn fetch-imports [meta] (|case (&meta/meta-get &meta/imports-tag meta) - (&/$Some (&/$ListM _parts)) + (&/$Some (&/$ListA _parts)) (&/map% (fn [_part] (|case _part - (&/$ListM (&/$Cons [(&/$TextM _module) - (&/$Cons [(&/$TextM _alias) + (&/$ListA (&/$Cons [(&/$TextA _module) + (&/$Cons [(&/$TextA _alias) (&/$Nil)])])) (return (&/T [_module _alias])) diff --git a/luxc/src/lux/base.clj b/luxc/src/lux/base.clj index 69dbdf5bf..f893f3a02 100644 --- a/luxc/src/lux/base.clj +++ b/luxc/src/lux/base.clj @@ -74,7 +74,7 @@ ("BoolS" 1) ("NatS" 1) ("IntS" 1) - ("FracS" 1) + ("DegS" 1) ("RealS" 1) ("CharS" 1) ("TextS" 1) @@ -216,16 +216,16 @@ ;; Meta-data (defvariant - ("BoolM" 1) - ("NatM" 1) - ("IntM" 1) - ("FracM" 1) - ("RealM" 1) - ("CharM" 1) - ("TextM" 1) - ("IdentM" 1) - ("ListM" 1) - ("DictM" 1)) + ("BoolA" 1) + ("NatA" 1) + ("IntA" 1) + ("DegA" 1) + ("RealA" 1) + ("CharA" 1) + ("TextA" 1) + ("IdentA" 1) + ("ListA" 1) + ("DictA" 1)) ;; [Exports] (def ^:const name-field "_name") @@ -1059,12 +1059,12 @@ (fn [state] (return* state (get$ $cursor state)))) -(def frac-bits 64) +(def deg-bits 64) (let [clean-separators (fn [^String input] (.replaceAll input "_" "")) - frac-text-to-digits (fn [^String input] - (loop [output (vec (repeat frac-bits 0)) + deg-text-to-digits (fn [^String input] + (loop [output (vec (repeat deg-bits 0)) index (dec (.length input))] (if (>= index 0) (let [digit (Byte/parseByte (.substring input index (inc index)))] @@ -1081,50 +1081,50 @@ (int (/ raw 10)) (assoc digits index (rem raw 10)))) digits))) - frac-digit-power (fn [level] - (loop [output (-> (vec (repeat frac-bits 0)) + deg-digit-power (fn [level] + (loop [output (-> (vec (repeat deg-bits 0)) (assoc level 1)) times level] (if (>= times 0) (recur (times5 level output) (dec times)) output))) - frac-digits-lt (fn frac-digits-lt + deg-digits-lt (fn deg-digits-lt ([subject param index] - (and (< index frac-bits) + (and (< index deg-bits) (or (< (get subject index) (get param index)) (and (= (get subject index) (get param index)) - (frac-digits-lt subject param (inc index)))))) + (deg-digits-lt subject param (inc index)))))) ([subject param] - (frac-digits-lt subject param 0))) - frac-digits-sub-once (fn [subject param-digit index] + (deg-digits-lt subject param 0))) + deg-digits-sub-once (fn [subject param-digit index] (if (>= (get subject index) param-digit) (update-in subject [index] #(- % param-digit)) (recur (update-in subject [index] #(- 10 (- param-digit %))) 1 (dec index)))) - frac-digits-sub (fn [subject param] + deg-digits-sub (fn [subject param] (loop [target subject - index (dec frac-bits)] + index (dec deg-bits)] (if (>= index 0) - (recur (frac-digits-sub-once target (get param index) index) + (recur (deg-digits-sub-once target (get param index) index) (dec index)) target))) - frac-digits-to-text (fn [digits] + deg-digits-to-text (fn [digits] (loop [output "" - index (dec frac-bits)] + index (dec deg-bits)] (if (>= index 0) (recur (-> (get digits index) (Character/forDigit 10) (str output)) (dec index)) output))) - add-frac-digit-powers (fn [dl dr] - (loop [index (dec frac-bits) - output (vec (repeat frac-bits 0)) + add-deg-digit-powers (fn [dl dr] + (loop [index (dec deg-bits) + output (vec (repeat deg-bits 0)) carry 0] (if (>= index 0) (let [raw (+ carry @@ -1134,45 +1134,45 @@ (assoc output index (rem raw 10)) (int (/ raw 10)))) output)))] - ;; Based on the LuxRT.encode_frac method - (defn encode-frac [input] + ;; Based on the LuxRT.encode_deg method + (defn encode-deg [input] (if (= 0 input) ".0" - (loop [index (dec frac-bits) - output (vec (repeat frac-bits 0))] + (loop [index (dec deg-bits) + output (vec (repeat deg-bits 0))] (if (>= index 0) (recur (dec index) (if (bit-test input index) - (->> (- (dec frac-bits) index) - frac-digit-power - (add-frac-digit-powers output)) + (->> (- (dec deg-bits) index) + deg-digit-power + (add-deg-digit-powers output)) output)) - (-> output frac-digits-to-text + (-> output deg-digits-to-text (->> (str ".")) (.split "0*$") (aget 0)))))) - ;; Based on the LuxRT.decode_frac method - (defn decode-frac [^String input] + ;; Based on the LuxRT.decode_deg method + (defn decode-deg [^String input] (if (and (.startsWith input ".") - (< (.length input) (inc frac-bits))) + (< (.length input) (inc deg-bits))) (loop [digits-left (-> input (.substring 1) clean-separators - frac-text-to-digits) + deg-text-to-digits) index 0 ouput 0] - (if (< index frac-bits) - (let [power-slice (frac-digit-power index)] - (if (not (frac-digits-lt digits-left power-slice)) - (recur (frac-digits-sub digits-left power-slice) + (if (< index deg-bits) + (let [power-slice (deg-digit-power index)] + (if (not (deg-digits-lt digits-left power-slice)) + (recur (deg-digits-sub digits-left power-slice) (inc index) - (bit-set ouput (- (dec frac-bits) index))) + (bit-set ouput (- (dec deg-bits) index))) (recur digits-left (inc index) ouput))) ouput)) - (throw (str "Bad format for Frac number: " input)))) + (throw (str "Bad format for Deg number: " input)))) ) (defn show-ast [ast] @@ -1186,8 +1186,8 @@ [_ ($IntS ?value)] (pr-str ?value) - [_ ($FracS ?value)] - (encode-frac ?value) + [_ ($DegS ?value)] + (encode-deg ?value) [_ ($RealS ?value)] (pr-str ?value) diff --git a/luxc/src/lux/compiler.clj b/luxc/src/lux/compiler.clj index 48c90e759..0c30c76e9 100644 --- a/luxc/src/lux/compiler.clj +++ b/luxc/src/lux/compiler.clj @@ -60,8 +60,8 @@ (&o/$int ?value) (&&lux/compile-int ?value) - (&o/$frac ?value) - (&&lux/compile-frac ?value) + (&o/$deg ?value) + (&&lux/compile-deg ?value) (&o/$real ?value) (&&lux/compile-real ?value) diff --git a/luxc/src/lux/compiler/cache.clj b/luxc/src/lux/compiler/cache.clj index dbb7945b8..436f778f5 100644 --- a/luxc/src/lux/compiler/cache.clj +++ b/luxc/src/lux/compiler/cache.clj @@ -136,7 +136,7 @@ 2 (let [[_name _alias] parts [_ __module __name] (re-find #"^(.*);(.*)$" _alias) def-class (&&/load-class! loader (str (&host-generics/->class-name __module) "." (&host/def-name __name))) - def-anns (&/|list (&/T [&a-meta/alias-tag (&/$IdentM (&/T [__module __name]))])) + def-anns (&/|list (&/T [&a-meta/alias-tag (&/$IdentA (&/T [__module __name]))])) def-value (get-field &/value-field def-class)] (|do [def-type (&a-module/def-type __module __name)] (&a-module/define module _name def-type def-anns def-value))) diff --git a/luxc/src/lux/compiler/cache/ann.clj b/luxc/src/lux/compiler/cache/ann.clj index 7f343d229..e2df55286 100644 --- a/luxc/src/lux/compiler/cache/ann.clj +++ b/luxc/src/lux/compiler/cache/ann.clj @@ -33,34 +33,34 @@ "(-> Ann-Value Text)" [ann] (|case ann - (&/$BoolM value) + (&/$BoolA value) (str "B" value stop) - (&/$NatM value) + (&/$NatA value) (str "N" value stop) - (&/$IntM value) + (&/$IntA value) (str "I" value stop) - (&/$FracM value) - (str "F" value stop) + (&/$DegA value) + (str "D" value stop) - (&/$RealM value) + (&/$RealA value) (str "R" value stop) - (&/$CharM value) + (&/$CharA value) (str "C" value stop) - (&/$TextM value) + (&/$TextA value) (serialize-text value) - (&/$IdentM ident) + (&/$IdentA ident) (serialize-ident ident) - (&/$ListM elems) + (&/$ListA elems) (str "L" (serialize-seq serialize-ann elems)) - (&/$DictM kvs) + (&/$DictA kvs) (str "D" (serialize-seq (fn [kv] (|let [[k v] kv] (str (serialize-text k) @@ -88,13 +88,13 @@ (let [[value* ^String input*] (.split (.substring input 1) stop 2)] [(<ctor> (<parser> value*)) input*]))) - ^:private deserialize-bool "B" &/$BoolM Boolean/parseBoolean - ^:private deserialize-nat "N" &/$NatM Long/parseLong - ^:private deserialize-int "I" &/$IntM Long/parseLong - ^:private deserialize-frac "F" &/$FracM Long/parseLong - ^:private deserialize-real "R" &/$RealM Double/parseDouble - ^:private deserialize-char "C" &/$CharM (fn [^String input] (.charAt input 0)) - ^:private deserialize-text "T" &/$TextM identity + ^:private deserialize-bool "B" &/$BoolA Boolean/parseBoolean + ^:private deserialize-nat "N" &/$NatA Long/parseLong + ^:private deserialize-int "I" &/$IntA Long/parseLong + ^:private deserialize-deg "D" &/$DegA Long/parseLong + ^:private deserialize-real "R" &/$RealA Double/parseDouble + ^:private deserialize-char "C" &/$CharA (fn [^String input] (.charAt input 0)) + ^:private deserialize-text "T" &/$TextA identity ) (defn ^:private deserialize-ident* [^String input] @@ -107,7 +107,7 @@ (when (.startsWith input "@") (let [[^String ident* ^String input*] (.split (.substring input 1) stop 2) [_module _name] (.split ident* ident-separator 2)] - [(&/$IdentM (&/T [_module _name])) input*]))) + [(&/$IdentA (&/T [_module _name])) input*]))) (defn ^:private deserialize-seq [deserializer ^String input] (cond (.startsWith input nil-signal) @@ -136,8 +136,8 @@ (.substring input 1))] [(<type> elems) input*]))) - ^:private deserialize-list "L" &/$ListM deserialize-ann - ^:private deserialize-dict "D" &/$DictM deserialize-kv + ^:private deserialize-list "L" &/$ListA deserialize-ann + ^:private deserialize-dict "D" &/$DictA deserialize-kv ) (defn ^:private deserialize-ann @@ -146,7 +146,7 @@ (or (deserialize-bool input) (deserialize-nat input) (deserialize-int input) - (deserialize-frac input) + (deserialize-deg input) (deserialize-real input) (deserialize-char input) (deserialize-text input) diff --git a/luxc/src/lux/compiler/case.clj b/luxc/src/lux/compiler/case.clj index afdcd3eed..416c93622 100644 --- a/luxc/src/lux/compiler/case.clj +++ b/luxc/src/lux/compiler/case.clj @@ -90,7 +90,7 @@ (.visitInsn Opcodes/LCMP) (.visitJumpInsn Opcodes/IFNE $else)) - (&o/$FracPM _value) + (&o/$DegPM _value) (doto writer stack-peek &&/unwrap-long diff --git a/luxc/src/lux/compiler/host.clj b/luxc/src/lux/compiler/host.clj index 5f98bcdb9..10a718093 100644 --- a/luxc/src/lux/compiler/host.clj +++ b/luxc/src/lux/compiler/host.clj @@ -777,9 +777,9 @@ (.visitInsn Opcodes/LCMP) ;; I )) -(defn ^:private compile-LuxRT-frac-methods [^ClassWriter =class] - (|let [frac-bits 64 - _ (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "mul_frac" "(JJ)J" nil nil) +(defn ^:private compile-LuxRT-deg-methods [^ClassWriter =class] + (|let [deg-bits 64 + _ (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "mul_deg" "(JJ)J" nil nil) ;; Based on: http://stackoverflow.com/a/31629280/6823464 (.visitCode) ;; Bottom part @@ -810,7 +810,7 @@ (.visitInsn Opcodes/LRETURN) (.visitMaxs 0 0) (.visitEnd)) - _ (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "div_frac" "(JJ)J" nil nil) + _ (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "div_deg" "(JJ)J" nil nil) (.visitCode) ;; Based on: http://stackoverflow.com/a/8510587/6823464 (.visitVarInsn Opcodes/LLOAD 0) @@ -821,7 +821,7 @@ (.visitInsn Opcodes/LRETURN) (.visitMaxs 0 0) (.visitEnd)) - _ (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "frac-to-real" "(J)D" nil nil) + _ (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "deg-to-real" "(J)D" nil nil) (.visitCode) ;; Translate high bytes (.visitVarInsn Opcodes/LLOAD 0) high-4b @@ -840,7 +840,7 @@ (.visitInsn Opcodes/DRETURN) (.visitMaxs 0 0) (.visitEnd)) - _ (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "real-to-frac" "(D)J" nil nil) + _ (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "real-to-deg" "(D)J" nil nil) (.visitCode) ;; Drop any excess (.visitVarInsn Opcodes/DLOAD 0) @@ -856,9 +856,9 @@ (.visitInsn Opcodes/DREM) (.visitLdcInsn (double (Math/pow 2 32))) (.visitInsn Opcodes/DMUL) - ;; Turn it into a frac + ;; Turn it into a deg (.visitInsn Opcodes/D2L) - ;; Turn the upper half into frac too + ;; Turn the upper half into deg too swap2 (.visitInsn Opcodes/D2L) ;; Combine both pieces @@ -908,10 +908,10 @@ (.visitEnd))) _ (let [$loop-start (new Label) $do-a-round (new Label)] - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "frac_digit_power" "(I)[B" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "deg_digit_power" "(I)[B" nil nil) (.visitCode) ;; Initialize digits array. - (.visitLdcInsn (int frac-bits)) + (.visitLdcInsn (int deg-bits)) (.visitIntInsn Opcodes/NEWARRAY Opcodes/T_BYTE) ;; {digits} (.visitInsn Opcodes/DUP) (.visitVarInsn Opcodes/ILOAD 0) @@ -945,11 +945,11 @@ (.visitEnd))) _ (let [$loop-start (new Label) $do-a-round (new Label)] - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "add_frac_digit_powers" "([B[B)[B" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "add_deg_digit_powers" "([B[B)[B" nil nil) (.visitCode) - (.visitLdcInsn (int (dec frac-bits))) + (.visitLdcInsn (int (dec deg-bits))) (.visitVarInsn Opcodes/ISTORE 2) ;; Index - (.visitLdcInsn (int frac-bits)) + (.visitLdcInsn (int deg-bits)) (.visitIntInsn Opcodes/NEWARRAY Opcodes/T_BYTE) (.visitVarInsn Opcodes/ASTORE 3) ;; added_digits (.visitLdcInsn (int 0)) ;; {carry} @@ -996,9 +996,9 @@ (.visitEnd))) _ (let [$loop-start (new Label) $do-a-round (new Label)] - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "frac_digits_to_text" "([B)Ljava/lang/String;" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "deg_digits_to_text" "([B)Ljava/lang/String;" nil nil) (.visitCode) - (.visitLdcInsn (int (dec frac-bits))) + (.visitLdcInsn (int (dec deg-bits))) (.visitVarInsn Opcodes/ISTORE 1) ;; Index (.visitLdcInsn "") ;; {text} ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -1034,7 +1034,7 @@ $not-set (new Label) $next-iteration (new Label) $normal-path (new Label)] - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "encode_frac" "(J)Ljava/lang/String;" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "encode_deg" "(J)Ljava/lang/String;" nil nil) (.visitCode) ;; A quick corner-case to handle. (.visitVarInsn Opcodes/LLOAD 0) @@ -1045,9 +1045,9 @@ (.visitInsn Opcodes/ARETURN) (.visitLabel $normal-path) ;; Normal case - (.visitLdcInsn (int (dec frac-bits))) + (.visitLdcInsn (int (dec deg-bits))) (.visitVarInsn Opcodes/ISTORE 2) ;; Index - (.visitLdcInsn (int frac-bits)) + (.visitLdcInsn (int deg-bits)) (.visitIntInsn Opcodes/NEWARRAY Opcodes/T_BYTE) (.visitVarInsn Opcodes/ASTORE 3) ;; digits ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -1058,7 +1058,7 @@ (.visitJumpInsn Opcodes/IFGE $do-a-round) ;; Prepare text to return. (.visitVarInsn Opcodes/ALOAD 3) - (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "frac_digits_to_text" "([B)Ljava/lang/String;") + (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "deg_digits_to_text" "([B)Ljava/lang/String;") (.visitLdcInsn ".") (.visitInsn Opcodes/SWAP) (.visitMethodInsn Opcodes/INVOKEVIRTUAL "java/lang/String" "concat" "(Ljava/lang/String;)Ljava/lang/String;") @@ -1076,12 +1076,12 @@ (.visitVarInsn Opcodes/ILOAD 2) bit-set-64? (.visitJumpInsn Opcodes/IFEQ $next-iteration) - (.visitLdcInsn (int (dec frac-bits))) + (.visitLdcInsn (int (dec deg-bits))) (.visitVarInsn Opcodes/ILOAD 2) (.visitInsn Opcodes/ISUB) - (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "frac_digit_power" "(I)[B") + (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "deg_digit_power" "(I)[B") (.visitVarInsn Opcodes/ALOAD 3) - (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "add_frac_digit_powers" "([B[B)[B") + (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "add_deg_digit_powers" "([B[B)[B") (.visitVarInsn Opcodes/ASTORE 3) (.visitJumpInsn Opcodes/GOTO $next-iteration) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -1104,14 +1104,14 @@ $do-a-round (new Label) $not-set (new Label) $next-iteration (new Label)] - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "frac_text_to_digits" "(Ljava/lang/String;)[B" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "deg_text_to_digits" "(Ljava/lang/String;)[B" nil nil) (.visitCode) (.visitVarInsn Opcodes/ALOAD 0) (.visitMethodInsn Opcodes/INVOKEVIRTUAL "java/lang/String" "length" "()I") (.visitLdcInsn (int 1)) (.visitInsn Opcodes/ISUB) (.visitVarInsn Opcodes/ISTORE 1) ;; Index - (.visitLdcInsn (int frac-bits)) + (.visitLdcInsn (int deg-bits)) (.visitIntInsn Opcodes/NEWARRAY Opcodes/T_BYTE) (.visitVarInsn Opcodes/ASTORE 2) ;; digits ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -1152,7 +1152,7 @@ $is-less-than (new Label) $is-equal (new Label)] ;; [B0 <= [B1 - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "frac_digits_lt" "([B[B)Z" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "deg_digits_lt" "([B[B)Z" nil nil) (.visitCode) (.visitLdcInsn (int 0)) (.visitVarInsn Opcodes/ISTORE 2) ;; Index @@ -1161,7 +1161,7 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (.visitLabel $loop-start) (.visitVarInsn Opcodes/ILOAD 2) - (.visitLdcInsn (int frac-bits)) + (.visitLdcInsn (int deg-bits)) (.visitJumpInsn Opcodes/IF_ICMPLT $do-a-round) (.visitLdcInsn false) (.visitInsn Opcodes/IRETURN) @@ -1204,7 +1204,7 @@ _ (let [$loop-start (new Label) $do-a-round (new Label) $simple-sub (new Label)] - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "frac_digits_sub_once" "([BBI)[B" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "deg_digits_sub_once" "([BBI)[B" nil nil) (.visitCode) (.visitLabel $loop-start) (.visitVarInsn Opcodes/ALOAD 0) @@ -1252,9 +1252,9 @@ (.visitEnd))) _ (let [$loop-start (new Label) $do-a-round (new Label)] - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "frac_digits_sub" "([B[B)[B" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "deg_digits_sub" "([B[B)[B" nil nil) (.visitCode) - (.visitLdcInsn (int (dec frac-bits))) + (.visitLdcInsn (int (dec deg-bits))) (.visitVarInsn Opcodes/ISTORE 2) ;; Index ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -1273,7 +1273,7 @@ (.visitVarInsn Opcodes/ILOAD 2) (.visitInsn Opcodes/BALOAD) ;; {target-digits, param-digit} (.visitVarInsn Opcodes/ILOAD 2) ;; {target-digits, param-digit, idx} - (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "frac_digits_sub_once" "([BBI)[B") + (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "deg_digits_sub_once" "([BBI)[B") (.visitVarInsn Opcodes/ASTORE 0) ;; Update target digits ;; Decrement index (.visitVarInsn Opcodes/ILOAD 2) @@ -1292,7 +1292,7 @@ $skip-power (new Label) $iterate (new Label) $bad-format (new Label)] - (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "decode_frac" "(Ljava/lang/String;)Ljava/lang/Object;" nil nil) + (doto (.visitMethod =class (+ Opcodes/ACC_PUBLIC Opcodes/ACC_STATIC) "decode_deg" "(Ljava/lang/String;)Ljava/lang/Object;" nil nil) (.visitCode) ;; Check prefix (.visitVarInsn Opcodes/ALOAD 0) @@ -1302,7 +1302,7 @@ ;; Check if size is valid (.visitVarInsn Opcodes/ALOAD 0) (.visitMethodInsn Opcodes/INVOKEVIRTUAL "java/lang/String" "length" "()I") - (.visitLdcInsn (int (inc frac-bits))) ;; It's increased, to account for the prefix . + (.visitLdcInsn (int (inc deg-bits))) ;; It's increased, to account for the prefix . (.visitJumpInsn Opcodes/IF_ICMPGT $bad-format) ;; Initialization (.visitTryCatchBlock $from $to $handler "java/lang/Exception") @@ -1311,7 +1311,7 @@ (.visitMethodInsn Opcodes/INVOKEVIRTUAL "java/lang/String" "substring" "(I)Ljava/lang/String;") (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "clean_separators" "(Ljava/lang/String;)Ljava/lang/String;") (.visitLabel $from) - (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "frac_text_to_digits" "(Ljava/lang/String;)[B") + (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "deg_text_to_digits" "(Ljava/lang/String;)[B") (.visitLabel $to) (.visitVarInsn Opcodes/ASTORE 0) ;; From test to digits... (.visitLdcInsn (int 0)) @@ -1323,7 +1323,7 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (.visitLabel $loop-start) (.visitVarInsn Opcodes/ILOAD 1) - (.visitLdcInsn (int frac-bits)) + (.visitLdcInsn (int deg-bits)) (.visitJumpInsn Opcodes/IF_ICMPLT $do-a-round) (.visitVarInsn Opcodes/LLOAD 2) &&/wrap-long @@ -1335,18 +1335,18 @@ (.visitLabel $do-a-round) (.visitVarInsn Opcodes/ALOAD 0) (.visitVarInsn Opcodes/ILOAD 1) - (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "frac_digit_power" "(I)[B") + (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "deg_digit_power" "(I)[B") (.visitInsn Opcodes/DUP2) - (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "frac_digits_lt" "([B[B)Z") + (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "deg_digits_lt" "([B[B)Z") (.visitJumpInsn Opcodes/IFNE $skip-power) ;; Subtract power - (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "frac_digits_sub" "([B[B)[B") + (.visitMethodInsn Opcodes/INVOKESTATIC "lux/LuxRT" "deg_digits_sub" "([B[B)[B") (.visitVarInsn Opcodes/ASTORE 0) ;; Set bit on output (.visitVarInsn Opcodes/LLOAD 2) (.visitLdcInsn (long 1)) (.visitVarInsn Opcodes/ILOAD 1) - (.visitLdcInsn (int (dec frac-bits))) + (.visitLdcInsn (int (dec deg-bits))) (.visitInsn Opcodes/SWAP) (.visitInsn Opcodes/ISUB) (.visitInsn Opcodes/LSHL) @@ -1760,7 +1760,7 @@ (compile-LuxRT-pm-methods) (compile-LuxRT-adt-methods) (compile-LuxRT-nat-methods) - (compile-LuxRT-frac-methods))]] + (compile-LuxRT-deg-methods))]] (&&/save-class! (second (string/split &&/lux-utils-class #"/")) (.toByteArray (doto =class .visitEnd))))) @@ -2441,10 +2441,10 @@ ^:private compile-nat-sub Opcodes/LSUB "java.lang.Long" "longValue" "()J" &&/wrap-long ^:private compile-nat-mul Opcodes/LMUL "java.lang.Long" "longValue" "()J" &&/wrap-long - ^:private compile-frac-add Opcodes/LADD "java.lang.Long" "longValue" "()J" &&/wrap-long - ^:private compile-frac-sub Opcodes/LSUB "java.lang.Long" "longValue" "()J" &&/wrap-long - ^:private compile-frac-rem Opcodes/LSUB "java.lang.Long" "longValue" "()J" &&/wrap-long - ^:private compile-frac-scale Opcodes/LMUL "java.lang.Long" "longValue" "()J" &&/wrap-long + ^:private compile-deg-add Opcodes/LADD "java.lang.Long" "longValue" "()J" &&/wrap-long + ^:private compile-deg-sub Opcodes/LSUB "java.lang.Long" "longValue" "()J" &&/wrap-long + ^:private compile-deg-rem Opcodes/LSUB "java.lang.Long" "longValue" "()J" &&/wrap-long + ^:private compile-deg-scale Opcodes/LMUL "java.lang.Long" "longValue" "()J" &&/wrap-long ) (do-template [<name> <comp-method>] @@ -2497,8 +2497,8 @@ ^:private compile-nat-eq 0 - ^:private compile-frac-eq 0 - ^:private compile-frac-lt -1 + ^:private compile-deg-eq 0 + ^:private compile-deg-lt -1 ) (let [+wrapper-class+ (&host-generics/->bytecode-class-name "java.lang.Long")] @@ -2538,8 +2538,8 @@ ^:private compile-nat-min-value (.visitLdcInsn 0) &&/wrap-long ^:private compile-nat-max-value (.visitLdcInsn -1) &&/wrap-long - ^:private compile-frac-min-value (.visitLdcInsn 0) &&/wrap-long - ^:private compile-frac-max-value (.visitLdcInsn -1) &&/wrap-long + ^:private compile-deg-min-value (.visitLdcInsn 0) &&/wrap-long + ^:private compile-deg-max-value (.visitLdcInsn -1) &&/wrap-long ) (do-template [<encode-name> <encode-method> <decode-name> <decode-method>] @@ -2563,7 +2563,7 @@ (return nil))))) ^:private compile-nat-encode "encode_nat" ^:private compile-nat-decode "decode_nat" - ^:private compile-frac-encode "encode_frac" ^:private compile-frac-decode "decode_frac" + ^:private compile-deg-encode "encode_deg" ^:private compile-deg-decode "decode_deg" ) (do-template [<name> <method>] @@ -2584,8 +2584,8 @@ &&/wrap-long)]] (return nil))) - ^:private compile-frac-mul "mul_frac" - ^:private compile-frac-div "div_frac" + ^:private compile-deg-mul "mul_deg" + ^:private compile-deg-div "div_deg" ) (do-template [<name> <class> <method> <sig> <unwrap> <wrap>] @@ -2600,8 +2600,8 @@ <wrap>)]] (return nil)))) - ^:private compile-frac-to-real "java.lang.Long" "frac-to-real" "(J)D" &&/unwrap-long &&/wrap-double - ^:private compile-real-to-frac "java.lang.Double" "real-to-frac" "(D)J" &&/unwrap-double &&/wrap-long + ^:private compile-deg-to-real "java.lang.Long" "deg-to-real" "(J)D" &&/unwrap-long &&/wrap-double + ^:private compile-real-to-deg "java.lang.Double" "real-to-deg" "(D)J" &&/unwrap-double &&/wrap-long ) (let [widen (fn [^MethodVisitor *writer*] @@ -2674,21 +2674,21 @@ "to-char" (compile-nat-to-char compile ?values special-args) ) - "frac" + "deg" (case proc-name - "+" (compile-frac-add compile ?values special-args) - "-" (compile-frac-sub compile ?values special-args) - "*" (compile-frac-mul compile ?values special-args) - "/" (compile-frac-div compile ?values special-args) - "%" (compile-frac-rem compile ?values special-args) - "=" (compile-frac-eq compile ?values special-args) - "<" (compile-frac-lt compile ?values special-args) - "encode" (compile-frac-encode compile ?values special-args) - "decode" (compile-frac-decode compile ?values special-args) - "max-value" (compile-frac-max-value compile ?values special-args) - "min-value" (compile-frac-min-value compile ?values special-args) - "to-real" (compile-frac-to-real compile ?values special-args) - "scale" (compile-frac-scale compile ?values special-args) + "+" (compile-deg-add compile ?values special-args) + "-" (compile-deg-sub compile ?values special-args) + "*" (compile-deg-mul compile ?values special-args) + "/" (compile-deg-div compile ?values special-args) + "%" (compile-deg-rem compile ?values special-args) + "=" (compile-deg-eq compile ?values special-args) + "<" (compile-deg-lt compile ?values special-args) + "encode" (compile-deg-encode compile ?values special-args) + "decode" (compile-deg-decode compile ?values special-args) + "max-value" (compile-deg-max-value compile ?values special-args) + "min-value" (compile-deg-min-value compile ?values special-args) + "to-real" (compile-deg-to-real compile ?values special-args) + "scale" (compile-deg-scale compile ?values special-args) ) "int" @@ -2698,7 +2698,7 @@ "real" (case proc-name - "to-frac" (compile-real-to-frac compile ?values special-args) + "to-deg" (compile-real-to-deg compile ?values special-args) ) "char" diff --git a/luxc/src/lux/compiler/lux.clj b/luxc/src/lux/compiler/lux.clj index 3d7c4aa7b..fd4130707 100644 --- a/luxc/src/lux/compiler/lux.clj +++ b/luxc/src/lux/compiler/lux.clj @@ -44,7 +44,7 @@ compile-nat "java/lang/Long" "J" long compile-int "java/lang/Long" "J" long - compile-frac "java/lang/Long" "J" long + compile-deg "java/lang/Long" "J" long compile-real "java/lang/Double" "D" double compile-char "java/lang/Character" "C" char ) @@ -260,7 +260,7 @@ (|do [module-name &/get-module-name class-loader &/loader] (|case (&a-meta/meta-get &a-meta/alias-tag ?meta) - (&/$Some (&/$IdentM [r-module r-name])) + (&/$Some (&/$IdentA [r-module r-name])) (if (= 1 (&/|length ?meta)) (|do [:let [current-class (&host-generics/->class-name (str (&host/->module-class r-module) "/" (&host/def-name r-name))) def-class (&&/load-class! class-loader current-class) @@ -311,7 +311,7 @@ :let [def-class (&&/load-class! class-loader (&host-generics/->class-name current-class)) def-type (&a/expr-type* ?body) is-type? (|case (&a-meta/meta-get &a-meta/type?-tag ?meta) - (&/$Some (&/$BoolM true)) + (&/$Some (&/$BoolA true)) true _ @@ -323,7 +323,7 @@ _ (&/without-repl-closure (&a-module/define module-name ?name def-type def-meta def-value)) _ (|case (&/T [is-type? (&a-meta/meta-get &a-meta/tags-tag def-meta)]) - [true (&/$Some (&/$ListM tags*))] + [true (&/$Some (&/$ListA tags*))] (|do [:let [was-exported? (|case (&a-meta/meta-get &a-meta/export?-tag def-meta) (&/$Some _) true @@ -332,7 +332,7 @@ false)] tags (&/map% (fn [tag*] (|case tag* - (&/$TextM tag) + (&/$TextA tag) (return tag) _ @@ -382,7 +382,7 @@ :let [def-class (&&/load-class! class-loader (&host-generics/->class-name current-class)) def-type (&a/expr-type* ?body) is-type? (|case (&a-meta/meta-get &a-meta/type?-tag ?meta) - (&/$Some (&/$BoolM true)) + (&/$Some (&/$BoolA true)) true _ @@ -394,7 +394,7 @@ _ (&/without-repl-closure (&a-module/define module-name ?name def-type def-meta def-value)) _ (|case (&/T [is-type? (&a-meta/meta-get &a-meta/tags-tag def-meta)]) - [true (&/$Some (&/$ListM tags*))] + [true (&/$Some (&/$ListA tags*))] (|do [:let [was-exported? (|case (&a-meta/meta-get &a-meta/export?-tag def-meta) (&/$Some _) true @@ -403,7 +403,7 @@ false)] tags (&/map% (fn [tag*] (|case tag* - (&/$TextM tag) + (&/$TextA tag) (return tag) _ diff --git a/luxc/src/lux/lexer.clj b/luxc/src/lux/lexer.clj index 819c130f0..9dc77b411 100644 --- a/luxc/src/lux/lexer.clj +++ b/luxc/src/lux/lexer.clj @@ -17,7 +17,7 @@ ("Bool" 1) ("Nat" 1) ("Int" 1) - ("Frac" 1) + ("Deg" 1) ("Real" 1) ("Char" 1) ("Text" 1) @@ -158,7 +158,7 @@ (|do [[meta _ token] (&reader/read-regex <regex>)] (return (&/T [meta (<tag> token)])))) - lex-bool $Bool #"^(true|false)" + lex-bool $Bool #"^(true|false)" ) (do-template [<name> <tag> <regex>] @@ -166,10 +166,10 @@ (|do [[meta _ token] (&reader/read-regex <regex>)] (return (&/T [meta (<tag> (string/replace token #"_" ""))])))) - lex-nat $Nat #"^\+(0|[1-9][0-9_]*)" - lex-int $Int #"^-?(0|[1-9][0-9_]*)" - lex-frac $Frac #"^(\.[0-9_]+)" - lex-real $Real #"^-?(0\.[0-9_]+|[1-9][0-9_]*\.[0-9_]+)(e-?[1-9][0-9_]*)?" + lex-nat $Nat #"^\+(0|[1-9][0-9_]*)" + lex-int $Int #"^-?(0|[1-9][0-9_]*)" + lex-deg $Deg #"^(\.[0-9_]+)" + lex-real $Real #"^-?(0\.[0-9_]+|[1-9][0-9_]*\.[0-9_]+)(e-?[1-9][0-9_]*)?" ) (def lex-char @@ -245,7 +245,7 @@ lex-bool lex-nat lex-real - lex-frac + lex-deg lex-int lex-char lex-text diff --git a/luxc/src/lux/optimizer.clj b/luxc/src/lux/optimizer.clj index 5c30dc44f..8ce8fc20e 100644 --- a/luxc/src/lux/optimizer.clj +++ b/luxc/src/lux/optimizer.clj @@ -13,7 +13,7 @@ ("bool" 1) ("nat" 1) ("int" 1) - ("frac" 1) + ("deg" 1) ("real" 1) ("char" 1) ("text" 1) @@ -75,8 +75,8 @@ ("NatPM" 1) ;; Compare the CDN with an integer value. ("IntPM" 1) - ;; Compare the CDN with a fractional value. - ("FracPM" 1) + ;; Compare the CDN with a degree value. + ("DegPM" 1) ;; Compare the CDN with a real value. ("RealPM" 1) ;; Compare the CDN with a character value. @@ -192,8 +192,8 @@ (&/|list ($IntPM _value) $PopPM) - (&a-case/$FracTestAC _value) - (&/|list ($FracPM _value) + (&a-case/$DegTestAC _value) + (&/|list ($DegPM _value) $PopPM) (&a-case/$RealTestAC _value) @@ -287,8 +287,8 @@ ($IntPM _value) (str "($IntPM " (pr-str _value) ")") - ($FracPM _value) - (str "($FracPM " (pr-str _value) ")") + ($DegPM _value) + (str "($DegPM " (pr-str _value) ")") ($RealPM _value) (str "($RealPM " (pr-str _value) ")") @@ -351,9 +351,9 @@ ($IntPM _pre-value) ($AltPM pre post)) - [($FracPM _pre-value) ($FracPM _post-value)] + [($DegPM _pre-value) ($DegPM _post-value)] (if (= _pre-value _post-value) - ($FracPM _pre-value) + ($DegPM _pre-value) ($AltPM pre post)) [($RealPM _pre-value) ($RealPM _post-value)] @@ -1079,8 +1079,8 @@ (&a/$int value) (&/T [meta ($int value)]) - (&a/$frac value) - (&/T [meta ($frac value)]) + (&a/$deg value) + (&/T [meta ($deg value)]) (&a/$real value) (&/T [meta ($real value)]) diff --git a/luxc/src/lux/parser.clj b/luxc/src/lux/parser.clj index ceafcd92e..c32528096 100644 --- a/luxc/src/lux/parser.clj +++ b/luxc/src/lux/parser.clj @@ -82,8 +82,8 @@ (&lexer/$Int ?value) (return (&/|list (&/T [meta (&/$IntS (Long/parseLong ?value))]))) - (&lexer/$Frac ?value) - (return (&/|list (&/T [meta (&/$FracS (&/decode-frac ?value))]))) + (&lexer/$Deg ?value) + (return (&/|list (&/T [meta (&/$DegS (&/decode-deg ?value))]))) (&lexer/$Real ?value) (return (&/|list (&/T [meta (&/$RealS (Double/parseDouble ?value))]))) diff --git a/luxc/src/lux/type.clj b/luxc/src/lux/type.clj index ba1dd0d70..099682775 100644 --- a/luxc/src/lux/type.clj +++ b/luxc/src/lux/type.clj @@ -30,7 +30,7 @@ (def Bool (&/$NamedT (&/T ["lux" "Bool"]) (&/$HostT "java.lang.Boolean" &/$Nil))) (def Nat (&/$NamedT (&/T ["lux" "Nat"]) (&/$HostT &&host/nat-data-tag &/$Nil))) -(def Frac (&/$NamedT (&/T ["lux" "Frac"]) (&/$HostT &&host/frac-data-tag &/$Nil))) +(def Deg (&/$NamedT (&/T ["lux" "Deg"]) (&/$HostT &&host/deg-data-tag &/$Nil))) (def Int (&/$NamedT (&/T ["lux" "Int"]) (&/$HostT "java.lang.Long" &/$Nil))) (def Real (&/$NamedT (&/T ["lux" "Real"]) (&/$HostT "java.lang.Double" &/$Nil))) (def Char (&/$NamedT (&/T ["lux" "Char"]) (&/$HostT "java.lang.Character" &/$Nil))) @@ -120,33 +120,33 @@ (let [Ann-Value (&/$AppT (&/$BoundT 0) (&/$BoundT 1))] (&/$AppT (&/$UnivQ empty-env (&/$SumT - ;; BoolM + ;; BoolA Bool (&/$SumT - ;; NatM + ;; NatA Nat (&/$SumT - ;; IntM + ;; IntA Int (&/$SumT - ;; FracM - Frac + ;; DegA + Deg (&/$SumT - ;; RealM + ;; RealA Real (&/$SumT - ;; CharM + ;; CharA Char (&/$SumT - ;; TextM + ;; TextA Text (&/$SumT - ;; IdentM + ;; IdentA Ident (&/$SumT - ;; ListM + ;; ListA (&/$AppT List Ann-Value) - ;; DictM + ;; DictA (&/$AppT List (&/$ProdT Text Ann-Value))))))))))) ) &/$VoidT)))) diff --git a/luxc/src/lux/type/host.clj b/luxc/src/lux/type/host.clj index 462e1aebe..33073fa34 100644 --- a/luxc/src/lux/type/host.clj +++ b/luxc/src/lux/type/host.clj @@ -17,7 +17,7 @@ (def array-data-tag "#Array") (def null-data-tag "#Null") (def nat-data-tag "#Nat") -(def frac-data-tag "#Frac") +(def deg-data-tag "#Deg") ;; [Utils] (defn ^:private trace-lineage* [^Class super-class ^Class sub-class] @@ -262,8 +262,8 @@ (try (cond (or (= "java.lang.Object" e!name) (and (= nat-data-tag e!name) (= nat-data-tag a!name)) - (and (= frac-data-tag e!name) - (= frac-data-tag a!name)) + (and (= deg-data-tag e!name) + (= deg-data-tag a!name)) (and (= null-data-tag e!name) (= null-data-tag a!name)) (and (not (primitive-type? e!name)) @@ -273,7 +273,7 @@ (or (and (= array-data-tag e!name) (not= array-data-tag a!name)) (= nat-data-tag e!name) (= nat-data-tag a!name) - (= frac-data-tag e!name) (= frac-data-tag a!name) + (= deg-data-tag e!name) (= deg-data-tag a!name) (= null-data-tag e!name) (= null-data-tag a!name)) (check-error "" (&/$HostT e!name e!params) (&/$HostT a!name a!params)) diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux index 76093eb29..bb53b987e 100644 --- a/stdlib/source/lux.lux +++ b/stdlib/source/lux.lux @@ -38,9 +38,9 @@ (+1 [["lux" "doc"] (+6 "Your standard, run-of-the-mill floating-point numbers.")] (+0))))) -(_lux_def Frac - (+12 ["lux" "Frac"] - (+0 "#Frac" (+0))) +(_lux_def Deg + (+12 ["lux" "Deg"] + (+0 "#Deg" (+0))) (+1 [["lux" "type?"] (+0 true)] (+1 [["lux" "export?"] (+0 true)] (+1 [["lux" "doc"] (+6 "Fractional numbers that live in the interval [0,1). @@ -221,56 +221,56 @@ #Nil)))) ## (type: #rec Ann-Value -## (#BoolM Bool) -## (#NatM Nat) -## (#IntM Int) -## (#FracM Frac) -## (#RealM Real) -## (#CharM Char) -## (#TextM Text) -## (#IdentM Ident) -## (#ListM (List Ann-Value)) -## (#DictM (List [Text Ann-Value]))) +## (#BoolA Bool) +## (#NatA Nat) +## (#IntA Int) +## (#DegA Deg) +## (#RealA Real) +## (#CharA Char) +## (#TextA Text) +## (#IdentA Ident) +## (#ListA (List Ann-Value)) +## (#DictA (List [Text Ann-Value]))) (_lux_def Ann-Value (#NamedT ["lux" "Ann-Value"] (_lux_case (#AppT (#BoundT +0) (#BoundT +1)) Ann-Value (#AppT (#UnivQ #Nil - (#SumT ## #BoolM + (#SumT ## #BoolA Bool - (#SumT ## #NatM + (#SumT ## #NatA Nat - (#SumT ## #IntM + (#SumT ## #IntA Int - (#SumT ## #FracM - Frac - (#SumT ## #RealM + (#SumT ## #DegA + Deg + (#SumT ## #RealA Real - (#SumT ## #CharM + (#SumT ## #CharA Char - (#SumT ## #TextM + (#SumT ## #TextA Text - (#SumT ## #IdentM + (#SumT ## #IdentA Ident - (#SumT ## #ListM + (#SumT ## #ListA (#AppT List Ann-Value) - ## #DictM + ## #DictA (#AppT List (#ProdT Text Ann-Value))))))))))) ) Void) )) (#Cons [["lux" "type?"] (+0 true)] (#Cons [["lux" "export?"] (+0 true)] - (#Cons [["lux" "tags"] (+8 (#Cons (+6 "BoolM") - (#Cons (+6 "NatM") - (#Cons (+6 "IntM") - (#Cons (+6 "FracM") - (#Cons (+6 "RealM") - (#Cons (+6 "CharM") - (#Cons (+6 "TextM") - (#Cons (+6 "IdentM") - (#Cons (+6 "ListM") - (#Cons (+6 "DictM") + (#Cons [["lux" "tags"] (+8 (#Cons (+6 "BoolA") + (#Cons (+6 "NatA") + (#Cons (+6 "IntA") + (#Cons (+6 "DegA") + (#Cons (+6 "RealA") + (#Cons (+6 "CharA") + (#Cons (+6 "TextA") + (#Cons (+6 "IdentA") + (#Cons (+6 "ListA") + (#Cons (+6 "DictA") #Nil)))))))))))] (#Cons [["lux" "type-rec?"] (+0 true)] (#Cons [["lux" "doc"] (+6 "The value of an individual annotation.")] @@ -281,21 +281,21 @@ (_lux_def Anns (#NamedT ["lux" "Anns"] (#AppT List (#ProdT Ident Ann-Value))) - (#Cons [["lux" "type?"] (#BoolM true)] - (#Cons [["lux" "export?"] (#BoolM true)] - (#Cons [["lux" "doc"] (#TextM "A set of annotations associated with a definition.")] + (#Cons [["lux" "type?"] (#BoolA true)] + (#Cons [["lux" "export?"] (#BoolA true)] + (#Cons [["lux" "doc"] (#TextA "A set of annotations associated with a definition.")] #Nil)))) (_lux_def default-def-meta-exported (_lux_: Anns - (#Cons [["lux" "type?"] (#BoolM true)] - (#Cons [["lux" "export?"] (#BoolM true)] + (#Cons [["lux" "type?"] (#BoolA true)] + (#Cons [["lux" "export?"] (#BoolA true)] #Nil))) #Nil) (_lux_def default-def-meta-unexported (_lux_: Anns - (#Cons [["lux" "type?"] (#BoolM true)] + (#Cons [["lux" "type?"] (#BoolA true)] #Nil)) #Nil) @@ -304,7 +304,7 @@ (_lux_def Def (#NamedT ["lux" "Def"] (#ProdT Type (#ProdT Anns Void))) - (#Cons [["lux" "doc"] (#TextM "Represents all the data associated with a definition: its type, its annotations, and its value.")] + (#Cons [["lux" "doc"] (#TextA "Represents all the data associated with a definition: its type, its annotations, and its value.")] default-def-meta-exported)) ## (type: (Bindings k v) @@ -320,10 +320,10 @@ (#AppT List (#ProdT (#BoundT +3) (#BoundT +1))))))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "counter") - (#Cons (#TextM "mappings") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "counter") + (#Cons (#TextA "mappings") #Nil)))] - (#Cons [["lux" "type-args"] (#ListM (#Cons (#TextM "k") (#Cons (#TextM "v") #;Nil)))] + (#Cons [["lux" "type-args"] (#ListA (#Cons (#TextA "k") (#Cons (#TextA "v") #;Nil)))] default-def-meta-exported))) ## (type: Cursor @@ -333,11 +333,11 @@ (_lux_def Cursor (#NamedT ["lux" "Cursor"] (#ProdT Text (#ProdT Int Int))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "module") - (#Cons (#TextM "line") - (#Cons (#TextM "column") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "module") + (#Cons (#TextA "line") + (#Cons (#TextA "column") #Nil))))] - (#Cons [["lux" "doc"] (#TextM "Cursors are for specifying the location of AST nodes in Lux files during compilation.")] + (#Cons [["lux" "doc"] (#TextA "Cursors are for specifying the location of AST nodes in Lux files during compilation.")] default-def-meta-exported))) ## (type: (Meta m v) @@ -349,11 +349,11 @@ (#UnivQ #Nil (#ProdT (#BoundT +3) (#BoundT +1))))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "meta") - (#Cons (#TextM "datum") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "meta") + (#Cons (#TextA "datum") #Nil)))] - (#Cons [["lux" "doc"] (#TextM "The type of things that can have meta-data of arbitrary types.")] - (#Cons [["lux" "type-args"] (#ListM (#Cons (#TextM "m") (#Cons (#TextM "v") #;Nil)))] + (#Cons [["lux" "doc"] (#TextA "The type of things that can have meta-data of arbitrary types.")] + (#Cons [["lux" "type-args"] (#ListA (#Cons (#TextA "m") (#Cons (#TextA "v") #;Nil)))] default-def-meta-exported)))) (_lux_def Analysis @@ -378,10 +378,10 @@ (#AppT (#AppT Bindings Text) Analysis) ## "lux;closure" (#AppT (#AppT Bindings Text) Analysis))))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "name") - (#Cons (#TextM "inner-closures") - (#Cons (#TextM "locals") - (#Cons (#TextM "closure") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "name") + (#Cons (#TextA "inner-closures") + (#Cons (#TextA "locals") + (#Cons (#TextA "closure") #Nil)))))] default-def-meta-exported)) @@ -389,7 +389,7 @@ ## (#BoolS Bool) ## (#NatS Nat) ## (#IntS Int) -## (#FracS Frac) +## (#DegS Deg) ## (#RealS Real) ## (#CharS Char) ## (#TextS Text) @@ -413,8 +413,8 @@ Nat (#SumT ## "lux;IntS" Int - (#SumT ## "lux;FracS" - Frac + (#SumT ## "lux;DegS" + Deg (#SumT ## "lux;RealS" Real (#SumT ## "lux;CharS" @@ -433,20 +433,20 @@ (#AppT List (#ProdT AST AST)) ))))))))))) )))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "BoolS") - (#Cons (#TextM "NatS") - (#Cons (#TextM "IntS") - (#Cons (#TextM "FracS") - (#Cons (#TextM "RealS") - (#Cons (#TextM "CharS") - (#Cons (#TextM "TextS") - (#Cons (#TextM "SymbolS") - (#Cons (#TextM "TagS") - (#Cons (#TextM "FormS") - (#Cons (#TextM "TupleS") - (#Cons (#TextM "RecordS") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "BoolS") + (#Cons (#TextA "NatS") + (#Cons (#TextA "IntS") + (#Cons (#TextA "DegS") + (#Cons (#TextA "RealS") + (#Cons (#TextA "CharS") + (#Cons (#TextA "TextS") + (#Cons (#TextA "SymbolS") + (#Cons (#TextA "TagS") + (#Cons (#TextA "FormS") + (#Cons (#TextA "TupleS") + (#Cons (#TextA "RecordS") #Nil)))))))))))))] - (#Cons [["lux" "type-args"] (#ListM (#Cons (#TextM "w") #;Nil))] + (#Cons [["lux" "type-args"] (#ListA (#Cons (#TextA "w") #;Nil))] default-def-meta-exported))) ## (type: AST @@ -456,7 +456,7 @@ (_lux_case (#AppT Meta Cursor) w (#AppT w (#AppT AST' w)))) - (#Cons [["lux" "doc"] (#TextM "The type of AST nodes for Lux syntax.")] + (#Cons [["lux" "doc"] (#TextA "The type of AST nodes for Lux syntax.")] default-def-meta-exported)) (_lux_def ASTList @@ -474,11 +474,11 @@ (#BoundT +3) ## "lux;Right" (#BoundT +1))))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "Left") - (#Cons (#TextM "Right") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "Left") + (#Cons (#TextA "Right") #Nil)))] - (#Cons [["lux" "type-args"] (#ListM (#Cons (#TextM "l") (#Cons (#TextM "r") #;Nil)))] - (#Cons [["lux" "doc"] (#TextM "A choice between two values of different types.")] + (#Cons [["lux" "type-args"] (#ListA (#Cons (#TextA "l") (#Cons (#TextA "r") #;Nil)))] + (#Cons [["lux" "doc"] (#TextA "A choice between two values of different types.")] default-def-meta-exported)))) ## (type: Source @@ -526,15 +526,15 @@ ## "lux;module-anns" Anns) )))))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "module-hash") - (#Cons (#TextM "module-aliases") - (#Cons (#TextM "defs") - (#Cons (#TextM "imports") - (#Cons (#TextM "tags") - (#Cons (#TextM "types") - (#Cons (#TextM "module-anns") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "module-hash") + (#Cons (#TextA "module-aliases") + (#Cons (#TextA "defs") + (#Cons (#TextA "imports") + (#Cons (#TextA "tags") + (#Cons (#TextA "types") + (#Cons (#TextA "module-anns") #Nil))))))))] - (#Cons [["lux" "doc"] (#TextM "All the information contained within a Lux module.")] + (#Cons [["lux" "doc"] (#TextA "All the information contained within a Lux module.")] default-def-meta-exported))) ## (type: Compiler-Mode @@ -552,12 +552,12 @@ #UnitT ## "lux;REPL" #UnitT)))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "Release") - (#Cons (#TextM "Debug") - (#Cons (#TextM "Eval") - (#Cons (#TextM "REPL") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "Release") + (#Cons (#TextA "Debug") + (#Cons (#TextA "Eval") + (#Cons (#TextA "REPL") #Nil)))))] - (#Cons [["lux" "doc"] (#TextM "A sign that shows the conditions under which the compiler is running.")] + (#Cons [["lux" "doc"] (#TextA "A sign that shows the conditions under which the compiler is running.")] default-def-meta-exported))) ## (type: Compiler-Info @@ -572,11 +572,11 @@ Text ## "lux;compiler-mode" Compiler-Mode))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "compiler-name") - (#Cons (#TextM "compiler-version") - (#Cons (#TextM "compiler-mode") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "compiler-name") + (#Cons (#TextA "compiler-version") + (#Cons (#TextA "compiler-mode") #Nil))))] - (#Cons [["lux" "doc"] (#TextM "Information about the current version and type of compiler that is running.")] + (#Cons [["lux" "doc"] (#TextA "Information about the current version and type of compiler that is running.")] default-def-meta-exported))) ## (type: Compiler @@ -613,18 +613,18 @@ (#AppT List Nat) ## "lux;host" Void)))))))))) - (#Cons [["lux" "tags"] (#ListM (#Cons (#TextM "info") - (#Cons (#TextM "source") - (#Cons (#TextM "cursor") - (#Cons (#TextM "modules") - (#Cons (#TextM "scopes") - (#Cons (#TextM "type-vars") - (#Cons (#TextM "expected") - (#Cons (#TextM "seed") - (#Cons (#TextM "scope-type-vars") - (#Cons (#TextM "host") + (#Cons [["lux" "tags"] (#ListA (#Cons (#TextA "info") + (#Cons (#TextA "source") + (#Cons (#TextA "cursor") + (#Cons (#TextA "modules") + (#Cons (#TextA "scopes") + (#Cons (#TextA "type-vars") + (#Cons (#TextA "expected") + (#Cons (#TextA "seed") + (#Cons (#TextA "scope-type-vars") + (#Cons (#TextA "host") #Nil)))))))))))] - (#Cons [["lux" "doc"] (#TextM "Represents the state of the Lux compiler during a run. + (#Cons [["lux" "doc"] (#TextA "Represents the state of the Lux compiler during a run. It is provided to macros during their invocation, so they can access compiler data. @@ -639,10 +639,10 @@ (#LambdaT Compiler (#AppT (#AppT Either Text) (#ProdT Compiler (#BoundT +1)))))) - (#Cons [["lux" "doc"] (#TextM "Computations that can have access to the state of the compiler. + (#Cons [["lux" "doc"] (#TextA "Computations that can have access to the state of the compiler. These computations may fail, or modify the state of the compiler.")] - (#Cons [["lux" "type-args"] (#ListM (#Cons (#TextM "a") #;Nil))] + (#Cons [["lux" "type-args"] (#ListA (#Cons (#TextA "a") #;Nil))] default-def-meta-exported))) ## (type: Macro @@ -650,7 +650,7 @@ (_lux_def Macro (#NamedT ["lux" "Macro"] (#LambdaT ASTList (#AppT Lux ASTList))) - (#Cons [["lux" "doc"] (#TextM "Functions that run at compile-time and allow you to transform and extend the language in powerful ways.")] + (#Cons [["lux" "doc"] (#TextA "Functions that run at compile-time and allow you to transform and extend the language in powerful ways.")] default-def-meta-exported)) ## Base functions & macros @@ -721,9 +721,9 @@ (_lux_lambda _ value (_meta (#IntS value)))) #Nil) -(_lux_def frac$ - (_lux_: (#LambdaT Frac AST) - (_lux_lambda _ value (_meta (#FracS value)))) +(_lux_def deg$ + (_lux_: (#LambdaT Deg AST) + (_lux_lambda _ value (_meta (#DegS value)))) #Nil) (_lux_def real$ @@ -768,7 +768,7 @@ (_lux_def default-macro-meta (_lux_: Anns - (#Cons [["lux" "macro?"] (#BoolM true)] + (#Cons [["lux" "macro?"] (#BoolA true)] #Nil)) #Nil) @@ -826,7 +826,7 @@ (_lux_def export?-meta (_lux_: AST (tuple$ (#Cons [(tuple$ (#Cons [(text$ "lux") (#Cons [(text$ "export?") #Nil])])) - (#Cons [(form$ (#Cons [(tag$ ["lux" "BoolM"]) + (#Cons [(form$ (#Cons [(tag$ ["lux" "BoolA"]) (#Cons [(bool$ true) #Nil])])) #Nil])]))) @@ -835,7 +835,7 @@ (_lux_def hidden?-meta (_lux_: AST (tuple$ (#Cons [(tuple$ (#Cons [(text$ "lux") (#Cons [(text$ "hidden?") #Nil])])) - (#Cons [(form$ (#Cons [(tag$ ["lux" "BoolM"]) + (#Cons [(form$ (#Cons [(tag$ ["lux" "BoolA"]) (#Cons [(bool$ true) #Nil])])) #Nil])]))) @@ -844,7 +844,7 @@ (_lux_def macro?-meta (_lux_: AST (tuple$ (#Cons [(tuple$ (#Cons [(text$ "lux") (#Cons [(text$ "macro?") #Nil])])) - (#Cons [(form$ (#Cons [(tag$ ["lux" "BoolM"]) + (#Cons [(form$ (#Cons [(tag$ ["lux" "BoolA"]) (#Cons [(bool$ true) #Nil])])) #Nil])]))) @@ -972,7 +972,7 @@ (fail "Wrong syntax for macro:'"))) (macro:' #export (comment tokens) - (#Cons [["lux" "doc"] (#TextM "## Throws away any code given to it. + (#Cons [["lux" "doc"] (#TextA "## Throws away any code given to it. ## Great for commenting-out code, while retaining syntax high-lighting and formatting in your text editor. (comment 1 2 3 4)")] #;Nil) @@ -1141,7 +1141,7 @@ (fold (lambda'' [_ acc] (_lux_proc ["jvm" "ladd"] [1 acc])) 0 list)) (macro:' #export (All tokens) - (#Cons [["lux" "doc"] (#TextM "## Universal quantification. + (#Cons [["lux" "doc"] (#TextA "## Universal quantification. (All [a] (-> a a)) @@ -1190,7 +1190,7 @@ )) (macro:' #export (Ex tokens) - (#Cons [["lux" "doc"] (#TextM "## Existential quantification. + (#Cons [["lux" "doc"] (#TextA "## Existential quantification. (Ex [a] [(Codec Text a) a]) @@ -1248,7 +1248,7 @@ list)) (macro:' #export (-> tokens) - (#Cons [["lux" "doc"] (#TextM "## Function types: + (#Cons [["lux" "doc"] (#TextA "## Function types: (-> Int Int Int) ## This is the type of a function that takes 2 Ints and returns an Int.")] @@ -1265,7 +1265,7 @@ (fail "Wrong syntax for ->"))) (macro:' #export (list xs) - (#Cons [["lux" "doc"] (#TextM "## List-construction macro. + (#Cons [["lux" "doc"] (#TextA "## List-construction macro. (list 1 2 3)")] #;Nil) (return (#Cons (fold (lambda'' [head tail] @@ -1277,7 +1277,7 @@ #Nil))) (macro:' #export (list& xs) - (#Cons [["lux" "doc"] (#TextM "## List-construction macro, with the last element being a tail-list. + (#Cons [["lux" "doc"] (#TextA "## List-construction macro, with the last element being a tail-list. ## In other words, this macro prepends elements to another list. (list& 1 2 3 (list 4 5 6))")] #;Nil) @@ -1293,7 +1293,7 @@ (fail "Wrong syntax for list&"))) (macro:' #export (& tokens) - (#Cons [["lux" "doc"] (#TextM "## Tuple types: + (#Cons [["lux" "doc"] (#TextA "## Tuple types: (& Text Int Bool) ## The empty tuple, a.k.a. Unit. @@ -1310,7 +1310,7 @@ )) (macro:' #export (| tokens) - (#Cons [["lux" "doc"] (#TextM "## Variant types: + (#Cons [["lux" "doc"] (#TextA "## Variant types: (| Text Int Bool) ## The empty tuple, a.k.a. Void. @@ -1474,7 +1474,7 @@ ys)) (def:''' #export (splice-helper xs ys) - (#Cons [["lux" "hidden?"] (#BoolM true)] + (#Cons [["lux" "hidden?"] (#BoolA true)] #;Nil) (-> ($' List AST) ($' List AST) ($' List AST)) (_lux_case xs @@ -1485,7 +1485,7 @@ ys)) (macro:' #export (_$ tokens) - (#Cons [["lux" "doc"] (#TextM "## Left-association for the application of binary functions over variadic arguments. + (#Cons [["lux" "doc"] (#TextA "## Left-association for the application of binary functions over variadic arguments. (_$ Text/append \"Hello, \" name \".\\nHow are you?\") ## => @@ -1506,7 +1506,7 @@ (fail "Wrong syntax for _$"))) (macro:' #export ($_ tokens) - (#Cons [["lux" "doc"] (#TextM "## Right-association for the application of binary functions over variadic arguments. + (#Cons [["lux" "doc"] (#TextA "## Right-association for the application of binary functions over variadic arguments. ($_ Text/append \"Hello, \" name \".\\nHow are you?\") ## => @@ -1532,7 +1532,7 @@ ## (: (All [a b] (-> (-> a (m b)) (m a) (m b))) ## bind)) (def:''' Monad - (list& [["lux" "tags"] (#ListM (list (#TextM "wrap") (#TextM "bind")))] + (list& [["lux" "tags"] (#ListA (list (#TextA "wrap") (#TextA "bind")))] default-def-meta-unexported) Type (#NamedT ["lux" "Monad"] @@ -1621,7 +1621,7 @@ ))) (macro:' #export (if tokens) - (list [["lux" "doc"] (#TextM "Picks which expression to evaluate based on a boolean test value. + (list [["lux" "doc"] (#TextA "Picks which expression to evaluate based on a boolean test value. (if true \"Oh, yeah!\" @@ -1706,7 +1706,7 @@ (_lux_case (get name defs) (#Some [def-type def-meta def-value]) (_lux_case (get-meta ["lux" "alias"] def-meta) - (#Some (#IdentM real-name)) + (#Some (#IdentA real-name)) (#Right [state real-name]) _ @@ -1768,8 +1768,8 @@ [_ [_ (#IntS value)]] (return (wrap-meta (form$ (list (tag$ ["lux" "IntS"]) (int$ value))))) - [_ [_ (#FracS value)]] - (return (wrap-meta (form$ (list (tag$ ["lux" "FracS"]) (frac$ value))))) + [_ [_ (#DegS value)]] + (return (wrap-meta (form$ (list (tag$ ["lux" "DegS"]) (deg$ value))))) [_ [_ (#RealS value)]] (return (wrap-meta (form$ (list (tag$ ["lux" "RealS"]) (real$ value))))) @@ -1838,7 +1838,7 @@ )) (macro:' #export (host tokens) - (list [["lux" "doc"] (#TextM "## Macro to treat host-types as Lux-types. + (list [["lux" "doc"] (#TextA "## Macro to treat host-types as Lux-types. (host java.lang.Object) (host java.util.List [java.lang.Long])")]) @@ -1869,7 +1869,7 @@ ))) (macro:' #export (` tokens) - (list [["lux" "doc"] (#TextM "## Hygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~@) must also be used as forms. + (list [["lux" "doc"] (#TextA "## Hygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~@) must also be used as forms. ## All unprefixed macros will receive their parent module's prefix if imported; otherwise will receive the prefix of the module on which the quasi-quote is being used. (` (def: (~ name) (lambda [(~@ args)] @@ -1885,7 +1885,7 @@ (fail "Wrong syntax for `"))) (macro:' #export (`' tokens) - (list [["lux" "doc"] (#TextM "## Unhygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~@) must also be used as forms. + (list [["lux" "doc"] (#TextA "## Unhygienic quasi-quotation as a macro. Unquote (~) and unquote-splice (~@) must also be used as forms. (`' (def: (~ name) (lambda [(~@ args)] (~ body))))")]) @@ -1899,7 +1899,7 @@ (fail "Wrong syntax for `"))) (macro:' #export (' tokens) - (list [["lux" "doc"] (#TextM "## Quotation as a macro. + (list [["lux" "doc"] (#TextA "## Quotation as a macro. (' \"YOLO\")")]) (_lux_case tokens (#Cons template #Nil) @@ -1911,7 +1911,7 @@ (fail "Wrong syntax for '"))) (macro:' #export (|> tokens) - (list [["lux" "doc"] (#TextM "## Piping macro. + (list [["lux" "doc"] (#TextA "## Piping macro. (|> elems (map ->Text) (interpose \" \") (fold Text/append \"\")) ## => @@ -1938,7 +1938,7 @@ (fail "Wrong syntax for |>"))) (macro:' #export (<| tokens) - (list [["lux" "doc"] (#TextM "## Reverse piping macro. + (list [["lux" "doc"] (#TextA "## Reverse piping macro. (<| (fold Text/append \"\") (interpose \" \") (map ->Text) elems) ## => @@ -1965,7 +1965,7 @@ (fail "Wrong syntax for <|"))) (def:''' #export (. f g) - (list [["lux" "doc"] (#TextM "Function composition.")]) + (list [["lux" "doc"] (#TextA "Function composition.")]) (All [a b c] (-> (-> b c) (-> a b) (-> a c))) (lambda' [x] (f (g x)))) @@ -2066,7 +2066,7 @@ (_lux_proc ["jvm" "invokevirtual:java.lang.Object:toString:"] [x])) (macro:' #export (do-template tokens) - (list [["lux" "doc"] (#TextM "## By specifying a pattern (with holes), and the input data to fill those holes, repeats the pattern as many times as necessary. + (list [["lux" "doc"] (#TextA "## By specifying a pattern (with holes), and the input data to fill those holes, repeats the pattern as many times as necessary. (do-template [<name> <diff>] [(def: #export <name> (-> Int Int) @@ -2097,29 +2097,29 @@ (do-template [<type> <category> <=-name> <=> <lt-name> <lte-name> <lt> <gt-name> <gte-name> <eq-doc> <<-doc> <<=-doc> <>-doc> <>=-doc>] [(def:''' #export (<=-name> test subject) - (list [["lux" "doc"] (#TextM <eq-doc>)]) + (list [["lux" "doc"] (#TextA <eq-doc>)]) (-> <type> <type> Bool) (_lux_proc [<category> <=>] [subject test])) (def:''' #export (<lt-name> test subject) - (list [["lux" "doc"] (#TextM <<-doc>)]) + (list [["lux" "doc"] (#TextA <<-doc>)]) (-> <type> <type> Bool) (_lux_proc [<category> <lt>] [subject test])) (def:''' #export (<lte-name> test subject) - (list [["lux" "doc"] (#TextM <<=-doc>)]) + (list [["lux" "doc"] (#TextA <<=-doc>)]) (-> <type> <type> Bool) (if (_lux_proc [<category> <lt>] [subject test]) true (_lux_proc [<category> <=>] [subject test]))) (def:''' #export (<gt-name> test subject) - (list [["lux" "doc"] (#TextM <>-doc>)]) + (list [["lux" "doc"] (#TextA <>-doc>)]) (-> <type> <type> Bool) (_lux_proc [<category> <lt>] [test subject])) (def:''' #export (<gte-name> test subject) - (list [["lux" "doc"] (#TextM <>=-doc>)]) + (list [["lux" "doc"] (#TextA <>=-doc>)]) (-> <type> <type> Bool) (if (_lux_proc [<category> <lt>] [test subject]) true @@ -2131,8 +2131,8 @@ [ Int "jvm" i.= "leq" i.< i.<= "llt" i.> i.>= "Integer equality." "Integer less-than." "Integer less-than-equal." "Integer greater-than." "Integer greater-than-equal."] - [Frac "frac" f.= "=" f.< f.<= "<" f.> f.>= - "Fractional equality." "Fractional less-than." "Fractional less-than-equal." "Fractional greater-than." "Fractional greater-than-equal."] + [Deg "deg" d.= "=" d.< d.<= "<" d.> d.>= + "Degree equality." "Degree less-than." "Degree less-than-equal." "Degree greater-than." "Degree greater-than-equal."] [Real "jvm" r.= "deq" r.< r.<= "dlt" r.> r.>= "Real equality." "Real less-than." "Real less-than-equal." "Real greater-than." "Real greater-than-equal."] @@ -2140,7 +2140,7 @@ (do-template [<type> <name> <op> <doc>] [(def:''' #export (<name> param subject) - (list [["lux" "doc"] (#TextM <doc>)]) + (list [["lux" "doc"] (#TextA <doc>)]) (-> <type> <type> <type>) (_lux_proc <op> [subject param]))] @@ -2156,11 +2156,11 @@ [ Int i./ ["jvm" "ldiv"] "Int(eger) division."] [ Int i.% ["jvm" "lrem"] "Int(eger) remainder."] - [Frac f.+ ["frac" "+"] "Frac(tional) addition."] - [Frac f.- ["frac" "-"] "Frac(tional) substraction."] - [Frac f.* ["frac" "*"] "Frac(tional) multiplication."] - [Frac f./ ["frac" "/"] "Frac(tional) division."] - [Frac f.% ["frac" "%"] "Frac(tional) remainder."] + [Deg d.+ ["deg" "+"] "Deg(ree) addition."] + [Deg d.- ["deg" "-"] "Deg(ree) substraction."] + [Deg d.* ["deg" "*"] "Deg(ree) multiplication."] + [Deg d./ ["deg" "/"] "Deg(ree) division."] + [Deg d.% ["deg" "%"] "Deg(ree) remainder."] [Real r.+ ["jvm" "dadd"] "Real addition."] [Real r.- ["jvm" "dsub"] "Real substraction."] @@ -2171,7 +2171,7 @@ (do-template [<name> <type> <test> <doc>] [(def:''' #export (<name> left right) - (list [["lux" "doc"] (#TextM <doc>)]) + (list [["lux" "doc"] (#TextA <doc>)]) (-> <type> <type> <type>) (if (<test> right left) left @@ -2183,8 +2183,8 @@ [i.min Int i.< "Int(eger) minimum."] [i.max Int i.> "Int(eger) maximum."] - [f.min Frac f.< "Frac(tional) minimum."] - [f.max Frac f.> "Frac(tional) maximum."] + [d.min Deg d.< "Deg(ree) minimum."] + [d.max Deg d.> "Deg(ree) maximum."] [r.min Real r.< "Real minimum."] [r.max Real r.> "Real minimum."] @@ -2196,7 +2196,7 @@ (i.= 0 (i.% div n))) (def:''' #export (not x) - (list [["lux" "doc"] (#TextM "## Boolean negation. + (list [["lux" "doc"] (#TextA "## Boolean negation. (not true) == false @@ -2215,9 +2215,9 @@ (get name bindings))] (let' [[def-type def-meta def-value] (_lux_: Def gdef)] (_lux_case (get-meta ["lux" "macro?"] def-meta) - (#Some (#BoolM true)) + (#Some (#BoolA true)) (_lux_case (get-meta ["lux" "export?"] def-meta) - (#Some (#BoolM true)) + (#Some (#BoolA true)) (#Some (_lux_:! Macro def-value)) _ @@ -2227,7 +2227,7 @@ _ (_lux_case (get-meta ["lux" "alias"] def-meta) - (#Some (#IdentM [r-module r-name])) + (#Some (#IdentA [r-module r-name])) (find-macro' modules current-module r-module r-name) _ @@ -2400,7 +2400,7 @@ type)) (macro:' #export (type tokens) - (list [["lux" "doc"] (#TextM "## Takes a type expression and returns it's representation as data-structure. + (list [["lux" "doc"] (#TextA "## Takes a type expression and returns it's representation as data-structure. (type (All [a] (Maybe (List a))))")]) (_lux_case tokens (#Cons type #Nil) @@ -2417,7 +2417,7 @@ (fail "Wrong syntax for type"))) (macro:' #export (: tokens) - (list [["lux" "doc"] (#TextM "## The type-annotation macro. + (list [["lux" "doc"] (#TextA "## The type-annotation macro. (: (List Int) (list 1 2 3))")]) (_lux_case tokens (#Cons type (#Cons value #Nil)) @@ -2427,7 +2427,7 @@ (fail "Wrong syntax for :"))) (macro:' #export (:! tokens) - (list [["lux" "doc"] (#TextM "## The type-coercion macro. + (list [["lux" "doc"] (#TextA "## The type-coercion macro. (:! Dinosaur (list 1 2 3))")]) (_lux_case tokens (#Cons type (#Cons value #Nil)) @@ -2523,7 +2523,7 @@ (symbol$ ["" ($_ Text/append "__gensym__" prefix (->Text seed))])))) (macro:' #export (Rec tokens) - (list [["lux" "doc"] (#TextM "## Parameter-less recursive types. + (list [["lux" "doc"] (#TextA "## Parameter-less recursive types. ## A name has to be given to the whole type, to use it within it's body. (Rec Self [Int (List Self)])")]) @@ -2536,7 +2536,7 @@ (fail "Wrong syntax for Rec"))) (macro:' #export (exec tokens) - (list [["lux" "doc"] (#TextM "## Sequential execution of expressions (great for side-effects). + (list [["lux" "doc"] (#TextA "## Sequential execution of expressions (great for side-effects). (exec (log! \"#1\") (log! \"#2\") @@ -2608,10 +2608,10 @@ (-> Nat Text) (_lux_proc ["nat" "encode"] [x])) -(def:''' (Frac->Text x) +(def:''' (Deg->Text x) #Nil - (-> Frac Text) - (_lux_proc ["frac" "encode"] [x])) + (-> Deg Text) + (_lux_proc ["deg" "encode"] [x])) (def:' (ast-to-text ast) (-> AST Text) @@ -2625,8 +2625,8 @@ [_ (#IntS value)] (->Text value) - [_ (#FracS value)] - (Frac->Text value) + [_ (#DegS value)] + (Deg->Text value) [_ (#RealS value)] (->Text value) @@ -2703,7 +2703,7 @@ (fold Text/append "")))))) (macro:' #export (case tokens) - (list [["lux" "doc"] (#TextM "## The pattern-matching macro. + (list [["lux" "doc"] (#TextA "## The pattern-matching macro. ## Allows the usage of macros within the patterns to provide custom syntax. (case (: (List Int) (list 1 2 3)) (#Cons x (#Cons y (#Cons z #Nil))) @@ -2721,7 +2721,7 @@ (fail "Wrong syntax for case"))) (macro:' #export (^ tokens) - (list [["lux" "doc"] (#TextM "## Macro-expanding patterns. + (list [["lux" "doc"] (#TextA "## Macro-expanding patterns. ## It's a special macro meant to be used with 'case'. (case (: (List Int) (list 1 2 3)) (^ (list x y z)) @@ -2744,7 +2744,7 @@ (fail "Wrong syntax for ^ macro"))) (macro:' #export (^or tokens) - (list [["lux" "doc"] (#TextM "## Or-patterns. + (list [["lux" "doc"] (#TextA "## Or-patterns. ## It's a special macro meant to be used with 'case'. (type: Weekday #Monday @@ -2787,7 +2787,7 @@ false)) (macro:' #export (let tokens) - (list [["lux" "doc"] (#TextM "## Creates local bindings. + (list [["lux" "doc"] (#TextA "## Creates local bindings. ## Can (optionally) use pattern-matching macros when binding. (let [x (foo bar) y (baz quux)] @@ -2811,7 +2811,7 @@ (fail "Wrong syntax for let"))) (macro:' #export (lambda tokens) - (list [["lux" "doc"] (#TextM "## Syntax for creating functions. + (list [["lux" "doc"] (#TextA "## Syntax for creating functions. ## Allows for giving the function itself a name, for the sake of recursion. (: (All [a b] (-> a b a)) (lambda [x y] x)) @@ -2850,28 +2850,28 @@ (-> AST (Lux AST)) (case ast [_ (#BoolS value)] - (return (form$ (list (tag$ ["lux" "BoolM"]) (bool$ value)))) + (return (form$ (list (tag$ ["lux" "BoolA"]) (bool$ value)))) [_ (#NatS value)] - (return (form$ (list (tag$ ["lux" "NatM"]) (nat$ value)))) + (return (form$ (list (tag$ ["lux" "NatA"]) (nat$ value)))) [_ (#IntS value)] - (return (form$ (list (tag$ ["lux" "IntM"]) (int$ value)))) + (return (form$ (list (tag$ ["lux" "IntA"]) (int$ value)))) - [_ (#FracS value)] - (return (form$ (list (tag$ ["lux" "FracM"]) (frac$ value)))) + [_ (#DegS value)] + (return (form$ (list (tag$ ["lux" "DegA"]) (deg$ value)))) [_ (#RealS value)] - (return (form$ (list (tag$ ["lux" "RealM"]) (real$ value)))) + (return (form$ (list (tag$ ["lux" "RealA"]) (real$ value)))) [_ (#CharS value)] - (return (form$ (list (tag$ ["lux" "CharM"]) (char$ value)))) + (return (form$ (list (tag$ ["lux" "CharA"]) (char$ value)))) [_ (#TextS value)] - (return (form$ (list (tag$ ["lux" "TextM"]) (text$ value)))) + (return (form$ (list (tag$ ["lux" "TextA"]) (text$ value)))) [_ (#TagS [prefix name])] - (return (form$ (list (tag$ ["lux" "IdentM"]) (tuple$ (list (text$ prefix) (text$ name)))))) + (return (form$ (list (tag$ ["lux" "IdentA"]) (tuple$ (list (text$ prefix) (text$ name)))))) (^or [_ (#FormS _)] [_ (#SymbolS _)]) (return ast) @@ -2879,7 +2879,7 @@ [_ (#TupleS xs)] (do Monad<Lux> [=xs (mapM Monad<Lux> process-def-meta-value xs)] - (wrap (form$ (list (tag$ ["lux" "ListM"]) (untemplate-list =xs))))) + (wrap (form$ (list (tag$ ["lux" "ListA"]) (untemplate-list =xs))))) [_ (#RecordS kvs)] (do Monad<Lux> @@ -2893,9 +2893,9 @@ (wrap (tuple$ (list (text$ =k) =v)))) _ - (fail (Text/append "Wrong syntax for DictM key: " (ast-to-text k)))))) + (fail (Text/append "Wrong syntax for DictA key: " (ast-to-text k)))))) kvs)] - (wrap (form$ (list (tag$ ["lux" "DictM"]) (untemplate-list =xs))))) + (wrap (form$ (list (tag$ ["lux" "DictA"]) (untemplate-list =xs))))) )) (def:' (process-def-meta ast) @@ -2929,15 +2929,15 @@ _ (` (#;Cons [["lux" "func-args"] - (#;ListM (list (~@ (map (lambda [arg] - (` (#;TextM (~ (text$ (ast-to-text arg)))))) + (#;ListA (list (~@ (map (lambda [arg] + (` (#;TextA (~ (text$ (ast-to-text arg)))))) args))))] (~ meta))))) (def:' (with-type-args args) (-> (List AST) AST) - (` {#;type-args (#;ListM (list (~@ (map (lambda [arg] - (` (#;TextM (~ (text$ (ast-to-text arg)))))) + (` {#;type-args (#;ListA (list (~@ (map (lambda [arg] + (` (#;TextA (~ (text$ (ast-to-text arg)))))) args))))})) (def:' Export-Level @@ -2972,7 +2972,7 @@ (list (' #hidden)))) (def:''' #export (log! message) - (list [["lux" "doc"] (#TextM "Logs message to standard output. + (list [["lux" "doc"] (#TextA "Logs message to standard output. Useful for debugging.")]) (-> Text Unit) @@ -2980,7 +2980,7 @@ [(_lux_proc ["jvm" "getstatic:java.lang.System:out"] []) message])) (macro:' #export (def: tokens) - (list [["lux" "doc"] (#TextM "## Defines global constants/functions. + (list [["lux" "doc"] (#TextA "## Defines global constants/functions. (def: (rejoin-pair pair) (-> [AST AST] (List AST)) (let [[left right] pair] @@ -3070,7 +3070,7 @@ base)) (macro:' #export (macro: tokens) - (list [["lux" "doc"] (#TextM "Macro-definition macro. + (list [["lux" "doc"] (#TextA "Macro-definition macro. (macro: #export (ident-for tokens) (case tokens @@ -3616,7 +3616,7 @@ (#Some tags) (` {#;tags [(~@ (map (: (-> Text AST) (lambda' [tag] - (form$ (list (tag$ ["lux" "TextM"]) + (form$ (list (tag$ ["lux" "TextA"]) (text$ tag))))) tags))] #;type? true}) @@ -3956,7 +3956,7 @@ (lambda [[name [def-type def-meta def-value]]] (case [(get-meta ["lux" "export?"] def-meta) (get-meta ["lux" "hidden?"] def-meta)] - [(#Some (#BoolM true)) #;None] + [(#Some (#BoolA true)) #;None] (list name) _ @@ -4436,7 +4436,7 @@ (lambda [def] (` (;_lux_def (~ (symbol$ ["" def])) (~ (symbol$ [module-name def])) - (#Cons [["lux" "alias"] (#IdentM [(~ (text$ module-name)) (~ (text$ def))])] + (#Cons [["lux" "alias"] (#IdentA [(~ (text$ module-name)) (~ (text$ def))])] #Nil))))) defs') openings (join-map (: (-> Openings (List AST)) @@ -4782,7 +4782,7 @@ ([#BoolS] [#NatS] [#IntS] - [#FracS] + [#DegS] [#RealS] [#CharS] [#TextS] @@ -4903,7 +4903,7 @@ ([#BoolS ->Text] [#NatS Nat->Text] [#IntS ->Text] - [#FracS Frac->Text] + [#DegS Deg->Text] [#RealS ->Text] [#CharS Char/encode] [#TextS Text/encode] @@ -4957,7 +4957,7 @@ (if (< 10 count) (recur (i.inc count) (f x)) x)))"} - (return (list (` (#;TextM (~ (|> tokens + (return (list (` (#;TextA (~ (|> tokens (map (. doc-fragment->Text identify-doc-fragment)) Text/join Text/trim @@ -5102,7 +5102,7 @@ (def: (place-tokens label tokens target) (-> Text (List AST) AST (Maybe (List AST))) (case target - (^or [_ (#BoolS _)] [_ (#NatS _)] [_ (#IntS _)] [_ (#FracS _)] [_ (#RealS _)] [_ (#CharS _)] [_ (#TextS _)] [_ (#TagS _)]) + (^or [_ (#BoolS _)] [_ (#NatS _)] [_ (#IntS _)] [_ (#DegS _)] [_ (#RealS _)] [_ (#CharS _)] [_ (#TextS _)] [_ (#TagS _)]) (#Some (list target)) [_ (#SymbolS [prefix name])] @@ -5193,7 +5193,7 @@ (["Bool"] ["Nat"] ["Int"] - ["Frac"] + ["Deg"] ["Real"] ["Char"] ["Text"]) @@ -5216,7 +5216,7 @@ (["Bool" Bool bool$] ["Nat" Nat nat$] ["Int" Int int$] - ["Frac" Frac frac$] + ["Deg" Deg deg$] ["Real" Real real$] ["Char" Char char$] ["Text" Text text$]) @@ -5577,11 +5577,11 @@ (-> <from> <to>) (_lux_proc <op> [input]))] - [int-to-nat ["int" "to-nat"] Int Nat] - [nat-to-int ["nat" "to-int"] Nat Int] + [int-to-nat ["int" "to-nat"] Int Nat] + [nat-to-int ["nat" "to-int"] Nat Int] - [real-to-frac ["real" "to-frac"] Real Frac] - [frac-to-real ["frac" "to-real"] Frac Real] + [real-to-deg ["real" "to-deg"] Real Deg] + [deg-to-real ["deg" "to-real"] Deg Real] ) (macro: #export (type-of tokens) diff --git a/stdlib/source/lux/compiler.lux b/stdlib/source/lux/compiler.lux index 374556972..367217524 100644 --- a/stdlib/source/lux/compiler.lux +++ b/stdlib/source/lux/compiler.lux @@ -170,14 +170,14 @@ _ #;None))] - [get-bool-ann #;BoolM Bool] - [get-int-ann #;IntM Int] - [get-real-ann #;RealM Real] - [get-char-ann #;CharM Char] - [get-text-ann #;TextM Text] - [get-ident-ann #;IdentM Ident] - [get-list-ann #;ListM (List Ann-Value)] - [get-dict-ann #;DictM (List [Text Ann-Value])] + [get-bool-ann #;BoolA Bool] + [get-int-ann #;IntA Int] + [get-real-ann #;RealA Real] + [get-char-ann #;CharA Char] + [get-text-ann #;TextA Text] + [get-ident-ann #;IdentA Ident] + [get-list-ann #;ListA (List Ann-Value)] + [get-dict-ann #;DictA (List [Text Ann-Value])] ) (def: #export (get-doc anns) @@ -189,7 +189,7 @@ {#;doc "Finds out whether an annotation-as-a-flag is set (has value 'true')."} (-> Ident Anns Bool) (case (get-ann flag-name anns) - (#;Some (#;BoolM true)) + (#;Some (#;BoolA true)) true _ @@ -197,7 +197,7 @@ (do-template [<name> <tag> <desc>] [(def: #export <name> - {#;doc (#;TextM ($_ Text/append "Checks whether a definition is " <desc> "."))} + {#;doc (#;TextA ($_ Text/append "Checks whether a definition is " <desc> "."))} (-> Anns Bool) (flag-set? (ident-for <tag>)))] @@ -220,13 +220,13 @@ _ #;None))] - [try-mlist #;ListM (List Ann-Value)] - [try-mtext #;TextM Text] + [try-mlist #;ListA (List Ann-Value)] + [try-mtext #;TextA Text] ) (do-template [<name> <tag> <desc>] [(def: #export (<name> anns) - {#;doc (#;TextM ($_ Text/append "Looks up the arguments of a " <desc> "."))} + {#;doc (#;TextA ($_ Text/append "Looks up the arguments of a " <desc> "."))} (-> Anns (List Text)) (default (list) (do Monad<Maybe> @@ -248,7 +248,7 @@ (or (export? def-anns) (Text/= module this-module))) (#;Some (:! Macro def-value)) (case (get-ann ["lux" "alias"] def-anns) - (#;Some (#;IdentM [r-module r-name])) + (#;Some (#;IdentA [r-module r-name])) (find-macro' modules this-module r-module r-name) _ @@ -602,7 +602,7 @@ [def-name (normalize def-name) [_ def-anns _] (find-def def-name)] (case (get-ann (ident-for #;alias) def-anns) - (#;Some (#;IdentM real-def-name)) + (#;Some (#;IdentA real-def-name)) (wrap real-def-name) _ diff --git a/stdlib/source/lux/control/ord.lux b/stdlib/source/lux/control/ord.lux index 0200d738a..8bd4ed906 100644 --- a/stdlib/source/lux/control/ord.lux +++ b/stdlib/source/lux/control/ord.lux @@ -18,7 +18,9 @@ (do-template [<name>] [(: (-> a a Bool) <name>)] - [<] [<=] [>] [>=])) + [<] [<=] [>] [>=] + ) + ) ## [Values] (def: #export (ord eq <) @@ -43,4 +45,5 @@ (if (:: ord <op> y x) x y))] [max >] - [min <]) + [min <] + ) diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux index d9ef60605..66ad6c093 100644 --- a/stdlib/source/lux/data/format/json.lux +++ b/stdlib/source/lux/data/format/json.lux @@ -190,7 +190,7 @@ (do-template [<name> <tag> <type> <desc>] [(def: #export (<name> key json) - {#;doc (#;TextM (format "A JSON object field getter for " <desc> "."))} + {#;doc (#;TextA (format "A JSON object field getter for " <desc> "."))} (-> Text JSON (Error <type>)) (case (get key json) (#;Right (<tag> value)) @@ -211,7 +211,7 @@ (do-template [<name> <type> <tag> <desc>] [(def: #export (<name> value) - {#;doc (#;TextM (format "A JSON generator for " <desc> "."))} + {#;doc (#;TextA (format "A JSON generator for " <desc> "."))} (Gen <type>) (<tag> value))] @@ -398,7 +398,7 @@ ## Syntax (do-template [<name> <type> <tag> <desc> <pre>] [(def: #export (<name> json) - {#;doc (#;TextM (format "Reads a JSON value as " <desc> "."))} + {#;doc (#;TextA (format "Reads a JSON value as " <desc> "."))} (Parser <type>) (case json (<tag> value) @@ -416,7 +416,7 @@ (do-template [<test> <check> <type> <eq> <codec> <tag> <desc> <pre>] [(def: #export (<test> test json) - {#;doc (#;TextM (format "Asks whether a JSON value is a " <desc> "."))} + {#;doc (#;TextA (format "Asks whether a JSON value is a " <desc> "."))} (-> <type> (Parser Bool)) (case json (<tag> value) @@ -426,7 +426,7 @@ (#;Left (format "JSON value is not a " <desc> ": " (show-json json))))) (def: #export (<check> test json) - {#;doc (#;TextM (format "Ensures a JSON value is a " <desc> "."))} + {#;doc (#;TextA (format "Ensures a JSON value is a " <desc> "."))} (-> <type> (Parser Unit)) (case json (<tag> value) diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux index c5b3277f8..695f9c7b9 100644 --- a/stdlib/source/lux/data/number.lux +++ b/stdlib/source/lux/data/number.lux @@ -22,7 +22,7 @@ [ Nat n.=] [ Int i.=] - [Frac f.=] + [Deg d.=] [Real r.=] ) @@ -36,7 +36,7 @@ [ Nat Eq<Nat> n.< n.<= n.> n.>=] [ Int Eq<Int> i.< i.<= i.> i.>=] - [Frac Eq<Frac> f.< f.<= f.> f.>=] + [Deg Eq<Deg> d.< d.<= d.> d.>=] [Real Eq<Real> r.< r.<= r.> r.>=] ) @@ -79,17 +79,17 @@ [Real Ord<Real> r.+ r.- r.* r./ r.% r.= r.< 0.0 1.0 -1.0] ) -(struct: #export _ (Number Frac) - (def: ord Ord<Frac>) - (def: + f.+) - (def: - f.-) - (def: * f.*) - (def: / f./) - (def: % f.%) - (def: (negate x) (f.- x (_lux_proc ["frac" "max-value"] []))) +(struct: #export _ (Number Deg) + (def: ord Ord<Deg>) + (def: + d.+) + (def: - d.-) + (def: * d.*) + (def: / d./) + (def: % d.%) + (def: (negate x) (d.- x (_lux_proc ["deg" "max-value"] []))) (def: abs id) (def: (signum x) - (_lux_proc ["frac" "max-value"] [])) + (_lux_proc ["deg" "max-value"] [])) ) (do-template [<type> <ord> <succ> <pred>] @@ -110,7 +110,7 @@ [ Nat (_lux_proc ["nat" "max-value"] []) (_lux_proc ["nat" "min-value"] [])] [ Int (_lux_proc ["jvm" "getstatic:java.lang.Long:MAX_VALUE"] []) (_lux_proc ["jvm" "getstatic:java.lang.Long:MIN_VALUE"] [])] [Real (_lux_proc ["jvm" "getstatic:java.lang.Double:MAX_VALUE"] []) (_lux_proc ["jvm" "getstatic:java.lang.Double:MIN_VALUE"] [])] - [Frac (_lux_proc ["frac" "max-value"] []) (_lux_proc ["frac" "min-value"] [])]) + [Deg (_lux_proc ["deg" "max-value"] []) (_lux_proc ["deg" "min-value"] [])]) (do-template [<name> <type> <unit> <append>] [(struct: #export <name> (Monoid <type>) @@ -129,10 +129,10 @@ [Mul@Monoid<Real> Real 1.0 r.*] [Max@Monoid<Real> Real (:: Bounded<Real> bottom) r.max] [Min@Monoid<Real> Real (:: Bounded<Real> top) r.min] - [Add@Monoid<Frac> Frac (:: Bounded<Frac> bottom) f.+] - [Mul@Monoid<Frac> Frac (:: Bounded<Frac> top) f.*] - [Max@Monoid<Frac> Frac (:: Bounded<Frac> bottom) f.max] - [Min@Monoid<Frac> Frac (:: Bounded<Frac> top) f.min] + [Add@Monoid<Deg> Deg (:: Bounded<Deg> bottom) d.+] + [Mul@Monoid<Deg> Deg (:: Bounded<Deg> top) d.*] + [Max@Monoid<Deg> Deg (:: Bounded<Deg> bottom) d.max] + [Min@Monoid<Deg> Deg (:: Bounded<Deg> top) d.min] ) (def: (text.replace pattern value template) @@ -153,7 +153,7 @@ (#;Left <error>))))] [Nat ["nat" "encode"] ["nat" "decode"] "Couldn't decode Nat"] - [Frac ["frac" "encode"] ["frac" "decode"] "Couldn't decode Frac"] + [Deg ["deg" "encode"] ["deg" "decode"] "Couldn't decode Deg"] ) (def: clean-number diff --git a/stdlib/source/lux/data/struct/set.lux b/stdlib/source/lux/data/struct/set.lux index 5f828ba43..711ae4553 100644 --- a/stdlib/source/lux/data/struct/set.lux +++ b/stdlib/source/lux/data/struct/set.lux @@ -47,9 +47,9 @@ (All [a] (-> (Set a) (Set a) (Set a))) (dict;merge xs yx)) -(def: #export (difference subs base) +(def: #export (difference sub base) (All [a] (-> (Set a) (Set a) (Set a))) - (List/fold remove base (to-list subs))) + (List/fold remove base (to-list sub))) (def: #export (intersection filter base) (All [a] (-> (Set a) (Set a) (Set a))) diff --git a/stdlib/source/lux/data/struct/tree.lux b/stdlib/source/lux/data/struct/tree/rose.lux index 8620e46a7..8620e46a7 100644 --- a/stdlib/source/lux/data/struct/tree.lux +++ b/stdlib/source/lux/data/struct/tree/rose.lux diff --git a/stdlib/source/lux/data/struct/zipper.lux b/stdlib/source/lux/data/struct/tree/zipper.lux index 2a447a65b..74dbd024f 100644 --- a/stdlib/source/lux/data/struct/zipper.lux +++ b/stdlib/source/lux/data/struct/tree/zipper.lux @@ -6,7 +6,7 @@ (;module: lux (lux (data (struct [list "" Monad<List> Fold<List> "List/" Monoid<List>] - [tree #+ Tree] + (tree [rose #+ Tree]) [stack #+ Stack])) [compiler] (macro [ast] @@ -36,11 +36,11 @@ (def: #export (value zipper) (All [a] (-> (Zipper a) a)) - (|> zipper (get@ #node) (get@ #tree;value))) + (|> zipper (get@ #node) (get@ #rose;value))) (def: #export (children zipper) (All [a] (-> (Zipper a) (List (Tree a)))) - (|> zipper (get@ #node) (get@ #tree;children))) + (|> zipper (get@ #node) (get@ #rose;children))) (def: #export (branch? zipper) (All [a] (-> (Zipper a) Bool)) @@ -76,7 +76,7 @@ (|> parent (update@ #node (: (-> (Tree ($ +0)) (Tree ($ +0))) (lambda [node] - (set@ #tree;children (List/append (list;reverse (get@ #lefts zipper)) + (set@ #rose;children (List/append (list;reverse (get@ #lefts zipper)) (#;Cons (get@ #node zipper) (get@ #rights zipper))) node))))))) @@ -112,26 +112,26 @@ (def: #export (set value zipper) (All [a] (-> a (Zipper a) (Zipper a))) - (set@ [#node #tree;value] value zipper)) + (set@ [#node #rose;value] value zipper)) (def: #export (update f zipper) (All [a] (-> (-> a a) (Zipper a) (Zipper a))) - (update@ [#node #tree;value] f zipper)) + (update@ [#node #rose;value] f zipper)) (def: #export (prepend-child value zipper) (All [a] (-> a (Zipper a) (Zipper a))) - (update@ [#node #tree;children] + (update@ [#node #rose;children] (lambda [children] - (#;Cons (tree;tree ($ +0) {value []}) + (#;Cons (rose;tree ($ +0) {value []}) children)) zipper)) (def: #export (append-child value zipper) (All [a] (-> a (Zipper a) (Zipper a))) - (update@ [#node #tree;children] + (update@ [#node #rose;children] (lambda [children] (List/append children - (list (tree;tree ($ +0) {value []})))) + (list (rose;tree ($ +0) {value []})))) zipper)) (def: #export (remove zipper) @@ -144,7 +144,7 @@ (#;Some next) (#;Some (|> next - (update@ [#node #tree;children] (|>. list;tail (default (list))))))) + (update@ [#node #rose;children] (|>. list;tail (default (list))))))) (#;Cons next side) (#;Some (|> zipper @@ -161,7 +161,7 @@ _ (#;Some (|> zipper (update@ <side> (lambda [side] - (#;Cons (tree;tree ($ +0) {value []}) + (#;Cons (rose;tree ($ +0) {value []}) side)))))))] [insert-left #lefts] diff --git a/stdlib/source/lux/data/text/format.lux b/stdlib/source/lux/data/text/format.lux index ebcb3fc48..2ae5c62ca 100644 --- a/stdlib/source/lux/data/text/format.lux +++ b/stdlib/source/lux/data/text/format.lux @@ -40,7 +40,7 @@ [%b Bool (:: bool;Codec<Text,Bool> encode)] [%n Nat (:: number;Codec<Text,Nat> encode)] [%i Int (:: number;Codec<Text,Int> encode)] - [%f Frac (:: number;Codec<Text,Frac> encode)] + [%f Deg (:: number;Codec<Text,Deg> encode)] [%r Real (:: number;Codec<Text,Real> encode)] [%c Char (:: char;Codec<Text,Char> encode)] [%t Text (:: text;Codec<Text,Text> encode)] diff --git a/stdlib/source/lux/lexer.lux b/stdlib/source/lux/lexer.lux index 787cbb0c5..ca8f7f5cf 100644 --- a/stdlib/source/lux/lexer.lux +++ b/stdlib/source/lux/lexer.lux @@ -317,7 +317,7 @@ (do-template [<name> <bottom> <top> <desc>] [(def: #export <name> - {#;doc (#;TextM ($_ Text/append "Only lex " <desc> " characters."))} + {#;doc (#;TextA ($_ Text/append "Only lex " <desc> " characters."))} (Lexer Char) (char-range <bottom> <top>))] diff --git a/stdlib/source/lux/regex.lux b/stdlib/source/lux/lexer/regex.lux index 5684a4465..5684a4465 100644 --- a/stdlib/source/lux/regex.lux +++ b/stdlib/source/lux/lexer/regex.lux diff --git a/stdlib/source/lux/macro/ast.lux b/stdlib/source/lux/macro/ast.lux index 8976ca64d..821264c09 100644 --- a/stdlib/source/lux/macro/ast.lux +++ b/stdlib/source/lux/macro/ast.lux @@ -43,7 +43,7 @@ [bool Bool #;BoolS] [nat Nat #;NatS] [int Int #;IntS] - [frac Frac #;FracS] + [deg Deg #;DegS] [real Real #;RealS] [char Char #;CharS] [text Text #;TextS] @@ -73,7 +73,7 @@ ([#;BoolS Eq<Bool>] [#;NatS Eq<Nat>] [#;IntS Eq<Int>] - [#;FracS Eq<Frac>] + [#;DegS Eq<Deg>] [#;RealS Eq<Real>] [#;CharS char;Eq<Char>] [#;TextS Eq<Text>] @@ -110,7 +110,7 @@ ([#;BoolS Codec<Text,Bool>] [#;NatS Codec<Text,Nat>] [#;IntS Codec<Text,Int>] - [#;FracS Codec<Text,Frac>] + [#;DegS Codec<Text,Deg>] [#;RealS Codec<Text,Real>] [#;CharS char;Codec<Text,Char>] [#;TextS text;Codec<Text,Text>] diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux index ec4a87068..d194a540b 100644 --- a/stdlib/source/lux/macro/poly.lux +++ b/stdlib/source/lux/macro/poly.lux @@ -59,7 +59,7 @@ [bool "Bool"] [nat "Nat"] [int "Int"] - [frac "Frac"] + [deg "Deg"] [real "Real"] [char "Char"] [text "Text"] @@ -78,7 +78,7 @@ [bool Bool] [nat Nat] [int Int] - [frac Frac] + [deg Deg] [real Real] [char Char] [text Text])] diff --git a/stdlib/source/lux/macro/poly/eq.lux b/stdlib/source/lux/macro/poly/eq.lux index dc37e0c9f..bdce71d50 100644 --- a/stdlib/source/lux/macro/poly/eq.lux +++ b/stdlib/source/lux/macro/poly/eq.lux @@ -50,7 +50,7 @@ [Bool poly;bool bool;Eq<Bool>] [Nat poly;nat number;Eq<Nat>] [Int poly;int number;Eq<Int>] - [Frac poly;frac number;Eq<Frac>] + [Deg poly;deg number;Eq<Deg>] [Real poly;real number;Eq<Real>] [Char poly;char char;Eq<Char>] [Text poly;text text;Eq<Text>])] diff --git a/stdlib/source/lux/macro/poly/text-encoder.lux b/stdlib/source/lux/macro/poly/text-encoder.lux index 858abc208..c538844a7 100644 --- a/stdlib/source/lux/macro/poly/text-encoder.lux +++ b/stdlib/source/lux/macro/poly/text-encoder.lux @@ -51,7 +51,7 @@ [Bool poly;bool (:: bool;Codec<Text,Bool> encode)] [Nat poly;nat (:: number;Codec<Text,Nat> encode)] [Int poly;int (:: number;Codec<Text,Int> encode)] - [Frac poly;frac (:: number;Codec<Text,Frac> encode)] + [Deg poly;deg (:: number;Codec<Text,Deg> encode)] [Real poly;real (:: number;Codec<Text,Real> encode)] [Char poly;char (:: char;Codec<Text,Char> encode)] [Text poly;text (:: text;Codec<Text,Text> encode)])] diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux index 45aaee1bb..ba24b607b 100644 --- a/stdlib/source/lux/macro/syntax.lux +++ b/stdlib/source/lux/macro/syntax.lux @@ -92,7 +92,7 @@ (do-template [<get-name> <type> <tag> <eq> <desc>] [(def: #export <get-name> - {#;doc (#;TextM ($_ Text/append "Parses the next " <desc> " input AST."))} + {#;doc (#;TextA ($_ Text/append "Parses the next " <desc> " input AST."))} (Syntax <type>) (lambda [tokens] (case tokens @@ -105,7 +105,7 @@ [ bool Bool #;BoolS bool;Eq<Bool> "bool"] [ nat Nat #;NatS number;Eq<Nat> "nat"] [ int Int #;IntS number;Eq<Int> "int"] - [ frac Frac #;FracS number;Eq<Frac> "frac"] + [ deg Deg #;DegS number;Eq<Deg> "deg"] [ real Real #;RealS number;Eq<Real> "real"] [ char Char #;CharS char;Eq<Char> "char"] [ text Text #;TextS text;Eq<Text> "text"] @@ -164,7 +164,7 @@ (do-template [<name> <tag> <desc>] [(def: #export <name> - {#;doc (#;TextM ($_ Text/append "Parse a local " <desc> " (a " <desc> " that has no module prefix)."))} + {#;doc (#;TextA ($_ Text/append "Parse a local " <desc> " (a " <desc> " that has no module prefix)."))} (Syntax Text) (lambda [tokens] (case tokens @@ -180,7 +180,7 @@ (do-template [<name> <tag> <desc>] [(def: #export (<name> p) - {#;doc (#;TextM ($_ Text/append "Parse inside the contents of a " <desc> " as if they were the input ASTs."))} + {#;doc (#;TextA ($_ Text/append "Parse inside the contents of a " <desc> " as if they were the input ASTs."))} (All [a] (-> (Syntax a) (Syntax a))) (lambda [tokens] @@ -198,7 +198,7 @@ ) (def: #export (record p) - {#;doc (#;TextM ($_ Text/append "Parse inside the contents of a record as if they were the input ASTs."))} + {#;doc (#;TextA ($_ Text/append "Parse inside the contents of a record as if they were the input ASTs."))} (All [a] (-> (Syntax a) (Syntax a))) (lambda [tokens] diff --git a/stdlib/source/lux/macro/syntax/common.lux b/stdlib/source/lux/macro/syntax/common.lux index 72faa2ada..96203b4c2 100644 --- a/stdlib/source/lux/macro/syntax/common.lux +++ b/stdlib/source/lux/macro/syntax/common.lux @@ -105,13 +105,13 @@ (def: list-meta^ (Syntax (List AST)) (s;form (do s;Monad<Syntax> - [_ (s;sample! (' #lux;ListM))] + [_ (s;sample! (' #lux;ListA))] (flat-list^ [])))) (def: text-meta^ (Syntax Text) (s;form (do s;Monad<Syntax> - [_ (s;sample! (' #lux;TextM))] + [_ (s;sample! (' #lux;TextA))] s;text))) (def: (find-def-args meta-data) diff --git a/stdlib/source/lux/math.lux b/stdlib/source/lux/math.lux index c1d855c8e..d5a03b421 100644 --- a/stdlib/source/lux/math.lux +++ b/stdlib/source/lux/math.lux @@ -57,6 +57,10 @@ [radians "invokestatic:java.lang.Math:toRadians:double"] ) +(def: #export (square n) + (-> Real Real) + (r.* n n)) + (do-template [<name> <method>] [(def: #export (<name> n) (-> Real Real) @@ -110,7 +114,7 @@ (s/map ast;bool s;bool) (s/map ast;nat s;nat) (s/map ast;int s;int) - (s/map ast;frac s;frac) + (s/map ast;deg s;deg) (s/map ast;real s;real) (s/map ast;char s;char) (s/map ast;text s;text) diff --git a/stdlib/source/lux/math/simple.lux b/stdlib/source/lux/math/simple.lux index 111e5cc8c..f8b059794 100644 --- a/stdlib/source/lux/math/simple.lux +++ b/stdlib/source/lux/math/simple.lux @@ -46,7 +46,7 @@ _ (wrap raw-type)))) -(do-template [<name> <rec> <nat-op> <int-op> <real-op> <frac-op>] +(do-template [<name> <rec> <nat-op> <int-op> <real-op> <deg-op>] [(syntax: #export (<name> [args ($_ s;alt (s;seq (s;alt s;symbol s;any) (s;some s;any)) @@ -58,7 +58,7 @@ ## (= (<name> 1.0 2.0) ## (<real-op> 1.0 2.0)) ## (= (<name> .1 .2) - ## (<frac-op> .1 .2)))} + ## (<deg-op> .1 .2)))} (case args (+0 [(#;Left x) ys]) (do @ @@ -72,8 +72,8 @@ (check;checks? Real =x) (wrap (` <real-op>)) - (check;checks? Frac =x) - (wrap (` <frac-op>)) + (check;checks? Deg =x) + (wrap (` <deg-op>)) (compiler;fail (format "No operation for types: " (%type =x))))] (wrap (list (` ($_ (~ op) (~ (ast;symbol x)) (~@ ys)))))) @@ -96,21 +96,21 @@ (check;checks? (-> Real Real Real) =e) (wrap (` <real-op>)) - (check;checks? (-> Frac Frac Frac) =e) - (wrap (` <frac-op>)) + (check;checks? (-> Deg Deg Deg) =e) + (wrap (` <deg-op>)) (compiler;fail (format "No operation for type: " (%type =e))))] (wrap (list op))) ))] - [+ ;;+ n.+ i.+ r.+ f.+] - [- ;;- n.- i.- r.- f.-] - [* ;;* n.* i.* r.* f.*] - [/ ;;/ n./ i./ r./ f./] - [% ;;% n.% i.% r.% f.%] + [+ ;;+ n.+ i.+ r.+ d.+] + [- ;;- n.- i.- r.- d.-] + [* ;;* n.* i.* r.* d.*] + [/ ;;/ n./ i./ r./ d./] + [% ;;% n.% i.% r.% d.%] ) -(do-template [<name> <rec> <nat-op> <int-op> <real-op> <frac-op>] +(do-template [<name> <rec> <nat-op> <int-op> <real-op> <deg-op>] [(syntax: #export (<name> [args ($_ s;alt (s;seq (s;alt s;symbol s;any) (s;some s;any)) @@ -122,7 +122,7 @@ ## (= (<name> 1.0 2.0) ## (<real-op> 1.0 2.0)) ## (= (<name> .1 .2) - ## (<frac-op> .1 .2)))} + ## (<deg-op> .1 .2)))} (case args (+0 [(#;Left x) ys]) (do @ @@ -136,8 +136,8 @@ (check;checks? Real =x) (wrap (` <real-op>)) - (check;checks? Frac =x) - (wrap (` <frac-op>)) + (check;checks? Deg =x) + (wrap (` <deg-op>)) (compiler;fail (format "No operation for types: " (%type =x))))] (wrap (list (` ($_ (~ op) (~ (ast;symbol x)) (~@ ys)))))) @@ -160,18 +160,18 @@ (check;checks? (-> Real Real Bool) =e) (wrap (` <real-op>)) - (check;checks? (-> Frac Frac Bool) =e) - (wrap (` <frac-op>)) + (check;checks? (-> Deg Deg Bool) =e) + (wrap (` <deg-op>)) (compiler;fail (format "No operation for type: " (%type =e))))] (wrap (list op))) ))] - [= ;;= n.= i.= r.= f.=] - [< ;;< n.< i.< r.< f.<] - [<= ;;<= n.<= i.<= r.<= f.<=] - [> ;;> n.> i.> r.> f.>] - [>= ;;>= n.>= i.>= r.>= f.>=] + [= ;;= n.= i.= r.= d.=] + [< ;;< n.< i.< r.< d.<] + [<= ;;<= n.<= i.<= r.<= d.<=] + [> ;;> n.> i.> r.> d.>] + [>= ;;>= n.>= i.>= r.>= d.>=] ) (do-template [<name> <rec> <nat-op> <int-op>] diff --git a/stdlib/source/lux/random.lux b/stdlib/source/lux/random.lux index 802dbfae6..195255643 100644 --- a/stdlib/source/lux/random.lux +++ b/stdlib/source/lux/random.lux @@ -100,9 +100,9 @@ int-to-real (r./ (|> +1 (bit;<< +53) nat-to-int int-to-real)))))) -(def: #export frac - (Random Frac) - (:: Monad<Random> map real-to-frac real)) +(def: #export deg + (Random Deg) + (:: Monad<Random> map real-to-deg real)) (def: #export char (Random Char) diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux index e7012f06e..9524a2168 100644 --- a/stdlib/source/lux/test.lux +++ b/stdlib/source/lux/test.lux @@ -247,7 +247,7 @@ body)] (with-gensyms [g!test] (wrap (list (` (def: #export (~ g!test) - {#;;test (#;TextM (~ description))} + {#;;test (#;TextA (~ description))} (IO Test) (io (~ body))))))))) diff --git a/stdlib/test/test/lux.lux b/stdlib/test/test/lux.lux index 6c1ea6f4b..cd394ac76 100644 --- a/stdlib/test/test/lux.lux +++ b/stdlib/test/test/lux.lux @@ -75,7 +75,7 @@ ["Int" R;int i.= i.< i.> i.<= i.>= i.min i.max] ["Nat" R;nat n.= n.< n.> n.<= n.>= n.min n.max] ["Real" R;real r.= r.< r.> r.<= r.>= r.min r.max] - ["Frac" R;frac f.= f.< f.> f.<= f.>= f.min f.max] + ["Deg" R;deg d.= d.< d.> d.<= d.>= d.min d.max] ) (do-template [category rand-gen = + - * / <%> > <0> <1> <factor> %x <cap> <prep>] @@ -97,10 +97,10 @@ (test: (format "[" category "] " "Multiplicative identity") [x rand-gen] (assert "" - ## Skip this test for Frac - ## because Frac division loses the last + ## Skip this test for Deg + ## because Deg division loses the last ## 32 bits of precision. - (or (T/= "Frac" category) + (or (T/= "Deg" category) (and (|> x (* <1>) (= x)) (|> x (/ <1>) (= x)))))) @@ -112,10 +112,10 @@ #let [r (<%> y x) x' (- r x)]] (assert "" - ## Skip this test for Frac - ## because Frac division loses the last + ## Skip this test for Deg + ## because Deg division loses the last ## 32 bits of precision. - (or (T/= "Frac" category) + (or (T/= "Deg" category) (or (> x' y) (|> x' (/ y) (* y) (= x')))) ))] @@ -123,7 +123,7 @@ ["Nat" R;nat n.= n.+ n.- n.* n./ n.% n.> +0 +1 +1000000 %n (n.% +1000) id] ["Int" R;int i.= i.+ i.- i.* i./ i.% i.> 0 1 1000000 %i (i.% 1000) id] ["Real" R;real r.= r.+ r.- r.* r./ r.% r.> 0.0 1.0 1000000.0 %r id math;floor] - ["Frac" R;frac f.= f.+ f.- f.* f./ f.% f.> .0 (_lux_proc ["frac" "max-value"] []) (_lux_proc ["frac" "max-value"] []) %f id id] + ["Deg" R;deg d.= d.+ d.- d.* d./ d.% d.> .0 (_lux_proc ["deg" "max-value"] []) (_lux_proc ["deg" "max-value"] []) %f id id] ) (do-template [category rand-gen -> <- = <cap> %a %z] @@ -137,7 +137,7 @@ ["Nat->Int" R;nat nat-to-int int-to-nat n.= (n.% +1000000) %n %i] ["Int->Real" R;int int-to-real real-to-int i.= (i.% 1000000) %i %r] ["Real->Int" R;real real-to-int int-to-real r.= math;floor %r %i] - ## [R;real real-to-frac frac-to-real r.= (r.% 1.0) %r %f] + ## [R;real real-to-deg deg-to-real r.= (r.% 1.0) %r %f] ) (test: "Simple macros and constructs" diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux index 20d72adf6..8b7267444 100644 --- a/stdlib/test/test/lux/data/number.lux +++ b/stdlib/test/test/lux/data/number.lux @@ -26,7 +26,7 @@ ["Nat" R;nat Eq<Nat> Ord<Nat>] ["Int" R;int Eq<Int> Ord<Int>] ["Real" R;real Eq<Real> Ord<Real>] - ["Frac" R;frac Eq<Frac> Ord<Frac>] + ["Deg" R;deg Eq<Deg> Ord<Deg>] ) (do-template [category rand-gen <Number>] @@ -39,14 +39,14 @@ (not (= x (negate x)))) (= x (negate (negate x))) ## There is loss of precision when multiplying - (or (Text/= "Frac" category) + (or (Text/= "Deg" category) (= x (* (signum x) (abs x)))))))] ## ["Nat" R;nat Number<Nat>] ["Int" R;int Number<Int>] ["Real" R;real Number<Real>] - ["Frac" R;frac Number<Frac>] + ["Deg" R;deg Number<Deg>] ) (do-template [category rand-gen <Enum> <Number>] @@ -79,7 +79,7 @@ ["Int" R;int Number<Int> Bounded<Int> (lambda [_] true)] ## Both min and max values will be positive (thus, greater than zero) ["Real" R;real Number<Real> Bounded<Real> (r.> 0.0)] - ["Frac" R;frac Number<Frac> Bounded<Frac> (lambda [_] true)] + ["Deg" R;deg Number<Deg> Bounded<Deg> (lambda [_] true)] ) (do-template [category rand-gen <Number> <Monoid> <cap> <test>] @@ -104,10 +104,10 @@ ["Real/Mul" R;real Number<Real> Mul@Monoid<Real> (r.% 1000.0) (r.> 0.0)] ["Real/Min" R;real Number<Real> Min@Monoid<Real> (r.% 1000.0) (r.> 0.0)] ["Real/Max" R;real Number<Real> Max@Monoid<Real> (r.% 1000.0) (r.> 0.0)] - ["Frac/Add" R;frac Number<Frac> Add@Monoid<Frac> (f.% .125) (lambda [_] true)] - ## ["Frac/Mul" R;frac Number<Frac> Mul@Monoid<Frac> (f.% .125) (lambda [_] true)] - ["Frac/Min" R;frac Number<Frac> Min@Monoid<Frac> (f.% .125) (lambda [_] true)] - ["Frac/Max" R;frac Number<Frac> Max@Monoid<Frac> (f.% .125) (lambda [_] true)] + ["Deg/Add" R;deg Number<Deg> Add@Monoid<Deg> (d.% .125) (lambda [_] true)] + ## ["Deg/Mul" R;deg Number<Deg> Mul@Monoid<Deg> (d.% .125) (lambda [_] true)] + ["Deg/Min" R;deg Number<Deg> Min@Monoid<Deg> (d.% .125) (lambda [_] true)] + ["Deg/Max" R;deg Number<Deg> Max@Monoid<Deg> (d.% .125) (lambda [_] true)] ) (do-template [<category> <rand-gen> <Number> <Codec>] @@ -126,7 +126,7 @@ ["Nat" R;nat Number<Nat> Codec<Text,Nat>] ["Int" R;int Number<Int> Codec<Text,Int>] ["Real" R;real Number<Real> Codec<Text,Real>] - ["Frac" R;frac Number<Frac> Codec<Text,Frac>] + ["Deg" R;deg Number<Deg> Codec<Text,Deg>] ) (do-template [<category> <rand-gen> <Number> <Codec>] diff --git a/stdlib/test/test/lux/data/struct/tree.lux b/stdlib/test/test/lux/data/struct/tree/rose.lux index 91a81355e..21592aba9 100644 --- a/stdlib/test/test/lux/data/struct/tree.lux +++ b/stdlib/test/test/lux/data/struct/tree/rose.lux @@ -7,7 +7,7 @@ lux (lux (codata [io]) (control monad) - (data (struct ["&" tree] + (data (struct (tree ["&" rose]) [list "List/" Monad<List>]) [number]) ["R" random] diff --git a/stdlib/test/test/lux/data/struct/zipper.lux b/stdlib/test/test/lux/data/struct/tree/zipper.lux index 37ada2859..f2d7fe708 100644 --- a/stdlib/test/test/lux/data/struct/zipper.lux +++ b/stdlib/test/test/lux/data/struct/tree/zipper.lux @@ -7,9 +7,9 @@ lux (lux (codata [io]) (control monad) - (data (struct ["&" zipper] - [tree] - [list "List/" Fold<List> Functor<List>]) + (data (struct [list "List/" Fold<List> Functor<List>] + (tree ["&" zipper] + [rose])) [text "Text/" Monoid<Text>] text/format [number]) @@ -19,7 +19,7 @@ lux/test) (def: gen-tree - (R;Random (tree;Tree Nat)) + (R;Random (rose;Tree Nat)) (R;rec (lambda [gen-tree] (do R;Monad<Random> ## Each branch can have, at most, 1 child. @@ -39,7 +39,7 @@ new-val R;nat pre-val R;nat post-val R;nat - #let [(^open "Tree/") (tree;Eq<Tree> number;Eq<Nat>) + #let [(^open "Tree/") (rose;Eq<Tree> number;Eq<Nat>) (^open "List/") (list;Eq<List> number;Eq<Nat>)]] ($_ seq (assert "Trees can be converted to/from zippers." @@ -102,7 +102,7 @@ (|> sample &;from-tree (&;set new-val) &;value (n.= new-val))) (assert "Zipper traversal follows the outline of the tree depth-first." - (List/= (tree;flatten sample) + (List/= (rose;flatten sample) (loop [zipper (&;from-tree sample)] (if (&;end? zipper) (list (&;value zipper)) @@ -110,7 +110,7 @@ (recur (&;next zipper))))))) (assert "Backwards zipper traversal yield reverse tree flatten." - (List/= (list;reverse (tree;flatten sample)) + (List/= (list;reverse (rose;flatten sample)) (loop [zipper (to-end (&;from-tree sample))] (if (&;root? zipper) (list (&;value zipper)) diff --git a/stdlib/test/test/lux/regex.lux b/stdlib/test/test/lux/lexer/regex.lux index 6c6854ce0..4a9f01c27 100644 --- a/stdlib/test/test/lux/regex.lux +++ b/stdlib/test/test/lux/lexer/regex.lux @@ -17,7 +17,7 @@ ["R" random] pipe [lexer] - ["&" regex]) + (lexer ["&" regex])) lux/test) ## [Utils] diff --git a/stdlib/test/test/lux/macro/syntax.lux b/stdlib/test/test/lux/macro/syntax.lux index 1fabb09ad..2755bbf8e 100644 --- a/stdlib/test/test/lux/macro/syntax.lux +++ b/stdlib/test/test/lux/macro/syntax.lux @@ -79,7 +79,7 @@ ["Can parse Bool syntax." true ast;bool bool;Eq<Bool> s;bool] ["Can parse Nat syntax." +123 ast;nat number;Eq<Nat> s;nat] ["Can parse Int syntax." 123 ast;int number;Eq<Int> s;int] - ["Can parse Frac syntax." .123 ast;frac number;Eq<Frac> s;frac] + ["Can parse Deg syntax." .123 ast;deg number;Eq<Deg> s;deg] ["Can parse Real syntax." 123.0 ast;real number;Eq<Real> s;real] ["Can parse Char syntax." #"\n" ast;char char;Eq<Char> s;char] ["Can parse Text syntax." "\n" ast;text text;Eq<Text> s;text] diff --git a/stdlib/test/test/lux/math/simple.lux b/stdlib/test/test/lux/math/simple.lux index bfa313708..235723f25 100644 --- a/stdlib/test/test/lux/math/simple.lux +++ b/stdlib/test/test/lux/math/simple.lux @@ -40,7 +40,7 @@ ["Nat" R;nat n.= n.+ n.- n.* n./ n.% +0] ["Int" R;int i.= i.+ i.- i.* i./ i.% 0] ["Real" R;real r.= r.+ r.- r.* r./ r.% 0.0] - ## ["Frac" R;frac f.= f.+ f.- f.* f./ f.% .0] + ["Deg" R;deg d.= d.+ d.- d.* d./ d.% .0] ) (do-template [<category> <generator> <lt> <lte> <gt> <gte>] @@ -61,7 +61,7 @@ ["Nat" R;nat n.< n.<= n.> n.>=] ["Int" R;int i.< i.<= i.> i.>=] ["Real" R;real r.< r.<= r.> r.>=] - ## ["Frac" R;frac f.< f.<= f.> f.>=] + ["Deg" R;deg d.< d.<= d.> d.>=] ) (do-template [<category> <generator> <=> <min> <max>] diff --git a/stdlib/test/tests.lux b/stdlib/test/tests.lux index c57ca61c5..8e0c165c1 100644 --- a/stdlib/test/tests.lux +++ b/stdlib/test/tests.lux @@ -15,7 +15,7 @@ ["_;" host] ["_;" pipe] ["_;" lexer] - ["_;" regex] + (lexer ["_;" regex]) (codata ["_;" io] ["_;" env] ["_;" state] @@ -47,9 +47,9 @@ [queue] [set] [stack] - [tree] ## [vector] - [zipper]) + (tree [rose] + [zipper])) (text [format]) ) ["_;" math] |