From b491dfff00219d5206075ea65468e00ab657075d Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Thu, 1 Dec 2022 20:03:21 -0400 Subject: Added simple benchmarking machinery. --- stdlib/source/library/lux/data/color.lux | 135 ++++++------------ stdlib/source/library/lux/data/color/hsb.lux | 152 +++++++++++++++++++++ stdlib/source/library/lux/data/color/hsl.lux | 39 +++--- stdlib/source/library/lux/math/number/i16.lux | 30 ++-- stdlib/source/library/lux/math/number/i32.lux | 34 ++--- stdlib/source/library/lux/math/number/i8.lux | 30 ++-- stdlib/source/library/lux/meta/type/quotient.lux | 86 ++++++------ stdlib/source/library/lux/meta/type/refinement.lux | 101 +++++++------- stdlib/source/library/lux/test/benchmark.lux | 54 ++++++++ stdlib/source/library/lux/world/money/currency.lux | 37 +++-- stdlib/source/library/lux/world/time/duration.lux | 4 + 11 files changed, 431 insertions(+), 271 deletions(-) create mode 100644 stdlib/source/library/lux/data/color/hsb.lux create mode 100644 stdlib/source/library/lux/test/benchmark.lux (limited to 'stdlib/source/library') diff --git a/stdlib/source/library/lux/data/color.lux b/stdlib/source/library/lux/data/color.lux index 23388a61c..fc79bb0db 100644 --- a/stdlib/source/library/lux/data/color.lux +++ b/stdlib/source/library/lux/data/color.lux @@ -22,24 +22,8 @@ ["[0]" nominal]]]]] [/ ["[0]" rgb (.only RGB)] - ["[0]" hsl]]) - -(def top - (-- rgb.limit)) - -(def rgb_factor - (|> top .int int.frac)) - -(def down - (-> Nat Frac) - (|>> .int int.frac (f./ rgb_factor))) - -(def up - (-> Frac Nat) - (|>> (f.* rgb_factor) f.int .nat)) - -(type .public HSB - [Frac Frac Frac]) + ["[0]" hsl] + ["[0]" hsb]]) (nominal.def .public Color RGB @@ -94,57 +78,6 @@ nominal.abstraction)) ) -(def .public (hsb color) - (-> Color HSB) - (let [[red green blue] (rgb color) - red (..down (rgb.number red)) - green (..down (rgb.number green)) - blue (..down (rgb.number blue)) - max (all f.max red green blue) - min (all f.min red green blue) - brightness max - diff (|> max (f.- min)) - saturation (if (f.= +0.0 max) - +0.0 - (|> diff (f./ max)))] - (if (f.= max min) - ... Achromatic - [+0.0 saturation brightness] - ... Chromatic - (let [hue (cond (f.= red max) - (|> green (f.- blue) (f./ diff) - (f.+ (if (f.< blue green) +6.0 +0.0))) - - (f.= green max) - (|> blue (f.- red) (f./ diff) - (f.+ +2.0)) - - ... (f.= blue max) - (|> red (f.- green) (f./ diff) - (f.+ +4.0)))] - [(|> hue (f./ +6.0)) - saturation - brightness])))) - -(def .public (of_hsb [hue saturation brightness]) - (-> HSB Color) - (let [hue (|> hue (f.* +6.0)) - i (f.floor hue) - f (|> hue (f.- i)) - p (|> +1.0 (f.- saturation) (f.* brightness)) - q (|> +1.0 (f.- (f.* f saturation)) (f.* brightness)) - t (|> +1.0 (f.- (|> +1.0 (f.- f) (f.* saturation))) (f.* brightness)) - v brightness - mod (|> i (f.% +6.0) f.int .nat) - red (when mod 0 v 1 q 2 p 3 p 4 t 5 v _ (undefined)) - green (when mod 0 t 1 v 2 v 3 q 4 p 5 p _ (undefined)) - blue (when mod 0 p 1 p 2 t 3 v 4 v 5 q _ (undefined))] - (|> (rgb.rgb (..up red) - (..up green) - (..up blue)) - try.trusted - of_rgb))) - (def (normal ratio) (-> Frac Frac) (cond (f.> +1.0 ratio) @@ -184,16 +117,15 @@ ) (with_template [ ] - [(def .public ( ratio color) + [(def .public ( ratio it) (-> Frac Color Color) - (let [color (hsl.of_rgb (rgb color))] - (|> (hsl.hsl (hsl.hue color) - (|> color + (let [it (hsl.of_rgb (rgb it))] + (|> (hsl.hsl (hsl.hue it) + (|> it hsl.saturation (f.* (|> +1.0 ( (..normal ratio)))) (f.min +1.0)) - (hsl.luminance color)) - try.trusted + (hsl.luminance it)) hsl.rgb of_rgb)))] @@ -207,7 +139,6 @@ (|> (hsl.hsl +0.0 +0.0 (hsl.luminance color)) - try.trusted hsl.rgb of_rgb))) @@ -222,13 +153,11 @@ (|> (hsl.hsl (|> hue (f.+ <1>) ..normal) saturation luminance) - try.trusted hsl.rgb of_rgb) (|> (hsl.hsl (|> hue (f.+ <2>) ..normal) saturation luminance) - try.trusted hsl.rgb of_rgb)])))] @@ -240,17 +169,20 @@ (with_template [ <1> <2> <3>] [(`` (def .public ( color) (-> Color [Color Color Color Color]) - (let [[hue saturation luminance] (hsb color)] + (let [it (hsl.of_rgb (..rgb color)) + hue (hsl.hue it) + saturation (hsl.saturation it) + luminance (hsl.luminance it) + of_hue (is (-> hsl.Value + Color) + (function (_ hue) + (|> (hsl.hsl hue saturation luminance) + hsl.rgb + ..of_rgb)))] [color - (of_hsb [(|> hue (f.+ <1>) ..normal) - saturation - luminance]) - (of_hsb [(|> hue (f.+ <2>) ..normal) - saturation - luminance]) - (of_hsb [(|> hue (f.+ <3>) ..normal) - saturation - luminance])])))] + (|> hue (f.+ <1>) ..normal of_hue) + (|> hue (f.+ <2>) ..normal of_hue) + (|> hue (f.+ <3>) ..normal of_hue)])))] [square (|> +1.0 (f./ +4.0)) (|> +2.0 (f./ +4.0)) (|> +3.0 (f./ +4.0))] [tetradic (|> +2.0 (f./ +12.0)) (|> +6.0 (f./ +12.0)) (|> +8.0 (f./ +12.0))] @@ -262,27 +194,36 @@ (type .public Palette (-> Spread Nat Color (List Color))) -(def .public (analogous spread variations color) +(def .public (analogous spread variations it) Palette - (let [[hue saturation brightness] (hsb color) + (let [it (hsl.of_rgb (..rgb it)) + hue (hsl.hue it) + saturation (hsl.saturation it) + luminance (hsl.luminance it) spread (..normal spread)] (list#each (function (_ idx) - (of_hsb [(|> idx ++ .int int.frac (f.* spread) (f.+ hue) ..normal) - saturation - brightness])) + (|> (hsl.hsl (|> idx ++ .int int.frac (f.* spread) (f.+ hue) ..normal) + saturation + luminance) + hsl.rgb + ..of_rgb)) (list.indices variations)))) -(def .public (monochromatic spread variations color) +(def .public (monochromatic spread variations it) Palette - (let [[hue saturation brightness] (hsb color) + (let [it (hsb.of_rgb (..rgb it)) + hue (hsb.hue it) + saturation (hsb.saturation it) + brightness (hsb.brightness it) spread (..normal spread)] (|> (list.indices variations) (list#each (|>> ++ .int int.frac (f.* spread) (f.+ brightness) ..normal - [hue saturation] - of_hsb))))) + (hsb.hsb hue saturation) + hsb.rgb + ..of_rgb))))) (type .public Alpha Rev) diff --git a/stdlib/source/library/lux/data/color/hsb.lux b/stdlib/source/library/lux/data/color/hsb.lux new file mode 100644 index 000000000..9f07a50eb --- /dev/null +++ b/stdlib/source/library/lux/data/color/hsb.lux @@ -0,0 +1,152 @@ +(.require + [library + [lux (.except) + [abstract + [equivalence (.only Equivalence)]] + [control + ["[0]" try] + [function + [predicate (.only Predicate)]]] + [math + [number + ["f" frac] + ["[0]" int]]] + [meta + [type + ["[0]" nominal]]]]] + [// + ["[0]" rgb (.only RGB)]]) + +(type .public Value + Frac) + +(with_template [ ] + [(def .public + Value + )] + + [+0.0 least] + [+1.0 most] + ) + +(def .public (value? it) + (Predicate Frac) + (not (or (f.< ..least it) + (f.> ..most it)))) + +(def .public value + (-> Frac + Value) + (|>> (f.max ..least) + (f.min ..most))) + +(nominal.def .public HSB + (Record + [#hue Value + #saturation Value + #brightness Value]) + + (def .public equivalence + (Equivalence HSB) + (implementation + (def (= left right) + (`` (and (,, (with_template [] + [(f.= (the (nominal.representation left)) + (the (nominal.representation right)))] + + [#hue] + [#saturation] + [#brightness] + ))))))) + + (with_template [ ] + [(def .public + (-> HSB + Value) + (|>> nominal.representation + (the )))] + + [hue #hue] + [saturation #saturation] + [brightness #brightness] + ) + + (def .public (hsb hue saturation brightness) + (-> Frac Frac Frac + HSB) + (nominal.abstraction + [#hue (..value hue) + #saturation (..value saturation) + #brightness (..value brightness)])) + + (def top + (-- rgb.limit)) + + (def rgb_factor + (|> top .int int.frac)) + + (def down + (-> Nat + Frac) + (|>> .int int.frac (f./ rgb_factor))) + + (def up + (-> Frac + Nat) + (|>> (f.* rgb_factor) f.int .nat)) + + (def .public (of_rgb it) + (-> RGB + HSB) + (let [red (..down (rgb.number (the rgb.#red it))) + green (..down (rgb.number (the rgb.#green it))) + blue (..down (rgb.number (the rgb.#blue it))) + + max (all f.max red green blue) + min (all f.min red green blue) + + brightness max + diff (|> max (f.- min)) + saturation (if (f.= +0.0 max) + +0.0 + (|> diff (f./ max)))] + (nominal.abstraction + [#hue (if (f.= max min) + ... Achromatic + +0.0 + ... Chromatic + (cond (f.= max red) + (|> green (f.- blue) (f./ diff) + (f.+ (if (f.< blue green) +6.0 +0.0))) + + (f.= max green) + (|> blue (f.- red) (f./ diff) + (f.+ +2.0)) + + ... (f.= max blue) + (|> red (f.- green) (f./ diff) + (f.+ +4.0)))) + #saturation saturation + #brightness brightness]))) + + (def .public (rgb it) + (-> HSB + RGB) + (let [[hue saturation brightness] (nominal.representation it) + hue (|> hue (f.* +6.0)) + i (f.floor hue) + f (|> hue (f.- i)) + p (|> +1.0 (f.- saturation) (f.* brightness)) + q (|> +1.0 (f.- (f.* f saturation)) (f.* brightness)) + t (|> +1.0 (f.- (|> +1.0 (f.- f) (f.* saturation))) (f.* brightness)) + v brightness + mod (|> i (f.% +6.0) f.int .nat) + + red (when mod 0 v 1 q 2 p 3 p 4 t 5 v _ (undefined)) + green (when mod 0 t 1 v 2 v 3 q 4 p 5 p _ (undefined)) + blue (when mod 0 p 1 p 2 t 3 v 4 v 5 q _ (undefined))] + (try.trusted + (rgb.rgb (..up red) + (..up green) + (..up blue))))) + ) diff --git a/stdlib/source/library/lux/data/color/hsl.lux b/stdlib/source/library/lux/data/color/hsl.lux index dd2155f2f..4a4c13097 100644 --- a/stdlib/source/library/lux/data/color/hsl.lux +++ b/stdlib/source/library/lux/data/color/hsl.lux @@ -5,8 +5,9 @@ [equivalence (.only Equivalence)] [monad (.only do)]] [control - ["[0]" try (.only Try)] - ["[0]" exception (.only Exception)]] + ["[0]" try] + [function + [predicate (.only Predicate)]]] [data [text ["%" \\format]]] @@ -48,20 +49,16 @@ [+1.0 most] ) -(exception.def .public (invalid value) - (Exception Frac) - (exception.report - (list ["Value" (%.frac value)] - ["Minimum" (%.frac ..least)] - ["Maximum" (%.frac ..most)]))) +(def .public (value? it) + (Predicate Frac) + (not (or (f.< ..least it) + (f.> ..most it)))) -(def .public (value it) +(def .public value (-> Frac - (Try Value)) - (if (or (f.< ..least it) - (f.> ..most it)) - (exception.except ..invalid [it]) - {try.#Success it})) + Value) + (|>> (f.max ..least) + (f.min ..most))) (nominal.def .public HSL (Record @@ -96,15 +93,11 @@ (def .public (hsl hue saturation luminance) (-> Frac Frac Frac - (Try HSL)) - (do try.monad - [hue (..value hue) - saturation (..value saturation) - luminance (..value luminance)] - (in (nominal.abstraction - [#hue hue - #saturation saturation - #luminance luminance])))) + HSL) + (nominal.abstraction + [#hue (..value hue) + #saturation (..value saturation) + #luminance (..value luminance)])) (def .public (of_rgb it) (-> RGB diff --git a/stdlib/source/library/lux/math/number/i16.lux b/stdlib/source/library/lux/math/number/i16.lux index 53c71f68f..04ee87a9e 100644 --- a/stdlib/source/library/lux/math/number/i16.lux +++ b/stdlib/source/library/lux/math/number/i16.lux @@ -4,29 +4,25 @@ [abstract [equivalence (.only Equivalence)]] [control - ["[0]" maybe]] + ["?" parser] + ["[0]" maybe] + ["[0]" try]] [meta - [type (.only by_example)]]]] + ["[0]" static] + ["[0]" type (.only) + ["?[1]" \\parser]]]]] [// - ["[0]" i64 (.only Sub)]]) + ["[0]" i64]]) (def sub (maybe.trusted (i64.sub 16))) -(def .public I16 - Type - ... TODO: Switch to the cleaner approach ASAP. - (when (type_of ..sub) - {.#Apply :size: :sub:} - (type_literal (I64 :size:)) - - _ - (undefined)) - ... (by_example [size] - ... (is (Sub size) - ... ..sub) - ... (I64 size)) - ) +(`` (type .public I16 + (I64 (,, (|> (type_of ..sub) + (?type.result (?type.applied (?.after (?type.exactly i64.Sub) + ?type.any))) + try.trusted + (static.literal type.code)))))) (def .public equivalence (Equivalence I16) (at ..sub sub_equivalence)) (def .public width Nat (at ..sub bits)) diff --git a/stdlib/source/library/lux/math/number/i32.lux b/stdlib/source/library/lux/math/number/i32.lux index af4d6d592..e2bce4938 100644 --- a/stdlib/source/library/lux/math/number/i32.lux +++ b/stdlib/source/library/lux/math/number/i32.lux @@ -4,31 +4,25 @@ [abstract [equivalence (.only Equivalence)]] [control - ["[0]" maybe]] + ["?" parser] + ["[0]" maybe] + ["[0]" try]] [meta - [type (.only by_example)]]]] + ["[0]" static] + ["[0]" type (.only) + ["?[1]" \\parser]]]]] [// - ["[0]" i64 (.only Sub)]]) + ["[0]" i64]]) (def sub - ... TODO: Stop needing this coercion. - (as (Sub (I64 (Nominal "#I32"))) - (maybe.trusted (i64.sub 32)))) + (maybe.trusted (i64.sub 32))) -(def .public I32 - Type - ... TODO: Switch to the cleaner approach ASAP. - (when (type_of ..sub) - {.#Apply :size: :sub:} - (type_literal (I64 :size:)) - - _ - (undefined)) - ... (by_example [size] - ... (is (Sub size) - ... ..sub) - ... (I64 size)) - ) +(`` (type .public I32 + (I64 (,, (|> (type_of ..sub) + (?type.result (?type.applied (?.after (?type.exactly i64.Sub) + ?type.any))) + try.trusted + (static.literal type.code)))))) (def .public equivalence (Equivalence I32) (at ..sub sub_equivalence)) (def .public width Nat (at ..sub bits)) diff --git a/stdlib/source/library/lux/math/number/i8.lux b/stdlib/source/library/lux/math/number/i8.lux index d4ac05aaf..5a36246c6 100644 --- a/stdlib/source/library/lux/math/number/i8.lux +++ b/stdlib/source/library/lux/math/number/i8.lux @@ -4,29 +4,25 @@ [abstract [equivalence (.only Equivalence)]] [control - ["[0]" maybe]] + ["?" parser] + ["[0]" maybe] + ["[0]" try]] [meta - [type (.only by_example)]]]] + ["[0]" static] + ["[0]" type (.only) + ["?[1]" \\parser]]]]] [// - ["[0]" i64 (.only Sub)]]) + ["[0]" i64]]) (def sub (maybe.trusted (i64.sub 8))) -(def .public I8 - Type - ... TODO: Switch to the cleaner approach ASAP. - (when (type_of ..sub) - {.#Apply :size: :sub:} - (type_literal (I64 :size:)) - - _ - (undefined)) - ... (by_example [size] - ... (is (Sub size) - ... ..sub) - ... (I64 size)) - ) +(`` (type .public I8 + (I64 (,, (|> (type_of ..sub) + (?type.result (?type.applied (?.after (?type.exactly i64.Sub) + ?type.any))) + try.trusted + (static.literal type.code)))))) (def .public equivalence (Equivalence I8) (at ..sub sub_equivalence)) (def .public width Nat (at ..sub bits)) diff --git a/stdlib/source/library/lux/meta/type/quotient.lux b/stdlib/source/library/lux/meta/type/quotient.lux index ab043d3ff..57b3ec811 100644 --- a/stdlib/source/library/lux/meta/type/quotient.lux +++ b/stdlib/source/library/lux/meta/type/quotient.lux @@ -2,69 +2,79 @@ [library [lux (.except type) [abstract - [equivalence (only Equivalence)]] - [meta + [equivalence (.only Equivalence)] + [monad (.only do)]] + [control + ["?" parser]] + ["[0]" meta (.only) ["[0]" code ["<[1]>" \\parser]] - [macro (.only with_symbols) + ["[0]" macro (.only) [syntax (.only syntax)]]]]] ["[0]" // (.only) + ["?[1]" \\parser] ["[0]" nominal (.except def)]]) -(nominal.def .public (Class t c %) - (-> t c) +(nominal.def .public (Class super sub %) + (-> super + sub) (def .public class - (All (_ t c) + (All (_ super sub) (Ex (_ %) - (-> (-> t c) (Class t c %)))) + (-> (-> super sub) + (Class super sub %)))) (|>> abstraction)) - (nominal.def .public (Quotient t c %) + (nominal.def .public (Quotient super sub %) (Record - [#value t - #label c]) + [#value super + #label sub]) (def .public (quotient class value) - (All (_ t c %) - (-> (Class t c %) t - (Quotient t c %))) + (All (_ super sub %) + (-> (Class super sub %) super + (Quotient super sub %))) (abstraction [#value value #label ((representation Class class) value)])) - (with_template [ ] + (with_template [ ] [(def .public - (All (_ t c %) (-> (Quotient t c %) )) - (|>> representation (the )))] + (All (_ super sub %) + (-> (Quotient super sub %) + )) + (|>> representation + (the )))] - [value t #value] - [label c #label] + [value #value super] + [label #label sub] ) ) ) (def .public type - (syntax (_ [class .any]) - ... TODO: Switch to the cleaner approach ASAP. - (with_symbols [g!t g!c g!% g!_ g!:quotient:] - (in (list (` (let [ ... (, g!_) (.is (.Ex ((, g!_) (, g!t) (, g!c) (, g!%)) - ... (..Class (, g!t) (, g!c) (, g!%))) - ... (, class)) - ] - (.when (.type_of (, class)) - {.#Apply (, g!%) {.#Apply (, g!c) {.#Apply (, g!t) (, g!:quotient:)}}} - (.type_literal (..Quotient (, g!t) (, g!c) (, g!%))) - - (, g!_) - (.undefined)))) - ... (` (//.by_example [(, g!t) (, g!c) (, g!%)] - ... (is (..Class (, g!t) (, g!c) (, g!%)) - ... (, class)) - ... (..Quotient (, g!t) (, g!c) (, g!%)))) - ))))) + (syntax (_ [it .any]) + (macro.with_symbols ['_ 'super 'sub '%] + (do meta.monad + [it (meta.eval Type (` (.type_of ((is (All ((, '_) (, 'super) (, 'sub) (, '%)) + (-> (..Class (, 'super) (, 'sub) (, '%)) + (..Class (, 'super) (, 'sub) (, '%)))) + (|>>)) + (, it))))) + [super sub %] (|> (as Type it) + (?//.result (?//.applied (?.after (?//.exactly ..Class) + (all ?.and ?//.any ?//.any ?//.any)))) + meta.of_try)] + (in (list (` (.type_literal (..Quotient (, (//.code super)) + (, (//.code sub)) + (, (//.code %))))))))))) (def .public (equivalence super) - (All (_ t c %) (-> (Equivalence c) (Equivalence (..Quotient t c %)))) + (All (_ super sub %) + (-> (Equivalence sub) + (Equivalence (..Quotient super sub %)))) (implementation (def (= reference sample) - (at super = (..label reference) (..label sample))))) + (at super = + (..label reference) + (..label sample))))) diff --git a/stdlib/source/library/lux/meta/type/refinement.lux b/stdlib/source/library/lux/meta/type/refinement.lux index f1778d1b1..f886f175c 100644 --- a/stdlib/source/library/lux/meta/type/refinement.lux +++ b/stdlib/source/library/lux/meta/type/refinement.lux @@ -1,48 +1,58 @@ (.require [library [lux (.except only type) + [abstract + [monad (.only do)]] [control + ["?" parser] [function [predicate (.only Predicate)]]] - [meta + ["[0]" meta (.only) ["[0]" code ["<[1]>" \\parser]] ["[0]" macro (.only) [syntax (.only syntax)]]]]] ["[0]" // (.only) + ["?[1]" \\parser] ["[0]" nominal (.except def)]]) -(nominal.def .public (Refined t %) +(nominal.def .public (Refined super %) (Record - [#value t - #predicate (Predicate t)]) + [#value super + #predicate (Predicate super)]) - (.type .public (Refiner t %) - (-> t (Maybe (Refined t %)))) + (.type .public (Refiner super %) + (-> super + (Maybe (Refined super %)))) (def .public (refiner predicate) - (All (_ t) + (All (_ super) (Ex (_ %) - (-> (Predicate t) (Refiner t %)))) + (-> (Predicate super) + (Refiner super %)))) (function (_ value) (if (predicate value) {.#Some (abstraction [#value value #predicate predicate])} {.#None}))) - (with_template [ ] + (with_template [ ] [(def .public - (All (_ t %) (-> (Refined t %) )) - (|>> representation (the )))] + (All (_ super %) + (-> (Refined super %) + )) + (|>> representation + (the )))] - [value t #value] - [predicate (Predicate t) #predicate] + [value #value super] + [predicate #predicate (Predicate super)] ) (def .public (lifted transform) - (All (_ t %) - (-> (-> t t) - (-> (Refined t %) (Maybe (Refined t %))))) + (All (_ super %) + (-> (-> super super) + (-> (Refined super %) + (Maybe (Refined super %))))) (function (_ refined) (let [(open "_[0]") (representation refined) value' (transform _#value)] @@ -53,27 +63,27 @@ ) (def .public (only refiner values) - (All (_ t %) - (-> (Refiner t %) (List t) (List (Refined t %)))) + (All (_ super %) + (-> (Refiner super %) (List super) + (List (Refined super %)))) (when values - {.#End} - {.#End} - {.#Item head tail} (when (refiner head) {.#Some refined} {.#Item refined (only refiner tail)} {.#None} - (only refiner tail)))) + (only refiner tail)) -(def .public (partition refiner values) - (All (_ t %) - (-> (Refiner t %) (List t) [(List (Refined t %)) (List t)])) - (when values {.#End} - [{.#End} {.#End}] + {.#End})) +(def .public (partition refiner values) + (All (_ super %) + (-> (Refiner super %) (List super) + [(List (Refined super %)) + (List super)])) + (when values {.#Item head tail} (let [[yes no] (partition refiner tail)] (when (refiner head) @@ -83,24 +93,23 @@ {.#None} [yes - {.#Item head no}])))) + {.#Item head no}])) -(def .public type - (syntax (_ [refiner .any]) - ... TODO: Switch to the cleaner approach ASAP. - (macro.with_symbols [g!t g!% g!_ g!:refiner:] - (in (list (` (let [ ... (, g!_) (.is (.Ex ((, g!_) (, g!t) (, g!%)) - ... (..Refined (, g!t) (, g!%))) - ... (, refiner)) - ] - (.when (.type_of (, refiner)) - {.#Apply (, g!%) {.#Apply (, g!t) (, g!:refiner:)}} - (.type_literal (..Refined (, g!t) (, g!%))) + {.#End} + [{.#End} {.#End}])) - (, g!_) - (.undefined)))) - ... (` (//.by_example [(, g!t) (, g!%)] - ... (is (..Refiner (, g!t) (, g!%)) - ... (, refiner)) - ... (..Refined (, g!t) (, g!%)))) - ))))) +(def .public type + (syntax (_ [it .any]) + (macro.with_symbols ['_ 'super '%] + (do meta.monad + [it (meta.eval Type (` (.type_of ((is (All ((, '_) (, 'super) (, '%)) + (-> (..Refiner (, 'super) (, '%)) + (..Refiner (, 'super) (, '%)))) + (|>>)) + (, it))))) + [super %] (|> (as Type it) + (?//.result (?//.applied (?.after (?//.exactly ..Refiner) + (all ?.and ?//.any ?//.any)))) + meta.of_try)] + (in (list (` (.type_literal (..Refined (, (//.code super)) + (, (//.code %))))))))))) diff --git a/stdlib/source/library/lux/test/benchmark.lux b/stdlib/source/library/lux/test/benchmark.lux new file mode 100644 index 000000000..427e62822 --- /dev/null +++ b/stdlib/source/library/lux/test/benchmark.lux @@ -0,0 +1,54 @@ +(.require + [library + [lux (.except) + [abstract + ["[0]" monad (.only do)] + ["[0]" order]] + [control + ["[0]" io (.only IO) (.use "[1]#[0]" monad)]] + [data + [collection + ["[0]" list (.use "[1]#[0]" mix)]]] + [world + [time + ["[0]" instant] + ["[0]" duration (.only Duration)]]]]]) + +(def .public (time subject) + (-> (IO Any) + (IO Duration)) + (do io.monad + [before instant.now + _ subject + after instant.now] + (in (instant.span before after)))) + +(type .public Benchmark + (Record + [#times Nat + #minimum Duration + #maximum Duration + #average Duration])) + +(def empty + Benchmark + [#times 0 + #minimum duration.empty + #maximum duration.empty + #average duration.empty]) + +(def .public (test times subject) + (-> Nat (IO Any) + (IO Benchmark)) + (when times + 0 (io#in ..empty) + _ (do [! io.monad] + [durations (|> subject + (list.repeated times) + (monad.each ! ..time))] + (in [#times times + #minimum (list#mix (order.min duration.order) duration.empty durations) + #maximum (list#mix (order.max duration.order) duration.empty durations) + #average (|> durations + (list#mix duration.composite duration.empty) + (duration.down times))])))) diff --git a/stdlib/source/library/lux/world/money/currency.lux b/stdlib/source/library/lux/world/money/currency.lux index fdb3ef16b..9b4abccda 100644 --- a/stdlib/source/library/lux/world/money/currency.lux +++ b/stdlib/source/library/lux/world/money/currency.lux @@ -3,15 +3,23 @@ [library [lux (.except type all try) [abstract - ["[0]" equivalence (.only Equivalence)]] + ["[0]" equivalence (.only Equivalence)] + [monad (.only do)]] + [control + ["?" parser]] [data ["[0]" product] ["[0]" text]] [math [number ["n" nat]]] - [meta - [type + ["[0]" meta (.only) + ["[0]" macro (.only) + [syntax (.only syntax)]] + ["[0]" code + ["?[1]" \\parser]] + ["[0]" type (.only) + ["?[1]" \\parser] ["[0]" nominal]]]]]) (nominal.def .public (Currency of) @@ -54,16 +62,19 @@ ) (def .public type - (template (_ ) - ... TODO: Switch to the cleaner approach ASAP. - [(when (type_of ) - {.#Apply it currency?} - (if (same? Currency currency?) - it - (undefined)) - - _ - (undefined))])) + (syntax (_ [it ?code.any]) + (macro.with_symbols ['_ 'of] + (do meta.monad + [it (meta.eval Type (` (.type_of ((is (All ((, '_) (, 'of)) + (-> (..Currency (, 'of)) + (..Currency (, 'of)))) + (|>>)) + (, it))))) + of (|> (as Type it) + (?type.result (?type.applied (?.after (?type.exactly ..Currency) + ?type.any))) + meta.of_try)] + (in (list (type.code of))))))) (def (power parameter subject) (-> Nat Nat diff --git a/stdlib/source/library/lux/world/time/duration.lux b/stdlib/source/library/lux/world/time/duration.lux index 627348295..fec1db917 100644 --- a/stdlib/source/library/lux/world/time/duration.lux +++ b/stdlib/source/library/lux/world/time/duration.lux @@ -86,13 +86,16 @@ ) (def .public empty + Duration (..of_millis +0)) (def .public milli_second + Duration (..of_millis +1)) (with_template [ ] [(def .public + Duration (..up ))] [second 1,000 milli_second] @@ -105,6 +108,7 @@ ) (def .public leap_year + Duration (..composite ..day ..normal_year)) (def .public monoid -- cgit v1.2.3