diff options
Diffstat (limited to '')
| -rw-r--r-- | new-luxc/source/luxc/lang/translation/jvm.lux | 19 | ||||
| -rw-r--r-- | new-luxc/test/test/luxc/common.lux | 123 | ||||
| -rw-r--r-- | new-luxc/test/test/luxc/lang/translation/function.lux | 173 | ||||
| -rw-r--r-- | new-luxc/test/test/luxc/lang/translation/primitive.lux | 37 | ||||
| -rw-r--r-- | new-luxc/test/test/luxc/lang/translation/structure.lux | 104 |
5 files changed, 229 insertions, 227 deletions
diff --git a/new-luxc/source/luxc/lang/translation/jvm.lux b/new-luxc/source/luxc/lang/translation/jvm.lux index 52b104149..8f4af43c6 100644 --- a/new-luxc/source/luxc/lang/translation/jvm.lux +++ b/new-luxc/source/luxc/lang/translation/jvm.lux @@ -160,7 +160,7 @@ (#error.Error error) (ex.throw invalid-field [class-name ..value-field]))) -(def: (eval store loader temp-label valueI) +(def: (evaluate! store loader temp-label valueI) (-> Store ClassLoader Text Inst (Error Any)) (do error.Monad<Error> [#let [eval-class (|> temp-label name.normalize (text.replace-all " " "$")) @@ -181,21 +181,20 @@ class (..load! eval-class loader)] (class-value eval-class class))) -(def: (define store loader temp-label [class-name class-bytecode]) +(def: (execute! store loader temp-label [class-name class-bytecode]) (-> Store ClassLoader Text Definition (Error Any)) (do error.Monad<Error> - [_ (..store! class-name class-bytecode store) - class (..load! class-name loader)] - (class-value class-name class))) + [_ (..store! class-name class-bytecode store)] + (..load! class-name loader))) (def: #export init - (IO State) + (IO Host) (io (let [store (: Store (atom (dictionary.new text.Hash<Text>))) loader (memory-class-loader store)] - (translation.init (: Host - (structure - (def: evaluate! (..eval store loader)) - (def: execute! (..define store loader)))))))) + (: Host + (structure + (def: evaluate! (..evaluate! store loader)) + (def: execute! (..execute! store loader))))))) (def: #export runtime-class "LuxRuntime") (def: #export function-class "LuxFunction") diff --git a/new-luxc/test/test/luxc/common.lux b/new-luxc/test/test/luxc/common.lux index b181004f7..87ecaed5c 100644 --- a/new-luxc/test/test/luxc/common.lux +++ b/new-luxc/test/test/luxc/common.lux @@ -2,77 +2,72 @@ [lux #* [control [monad (#+ do)]] - [io (#+ IO)] + ["." io (#+ IO)] [data [error (#+ Error)]] ["." macro - [code]] - ["." language - [compiler - [init] - [analysis - [module]] - [synthesis (#+ Synthesis)]]]] + ["." code]] + [compiler + ["." default + ["." init] + ["." phase + ["." analysis + ["." module]] + [synthesis (#+ Synthesis)] + ["." translation] + [extension + ["." bundle]]]]]] [luxc [lang + [host + [jvm (#+ Inst State Operation Phase Bundle)]] [translation ["." jvm + ["._jvm" runtime] ["._jvm" expression] - ## ["._jvm" eval] - ## ["._jvm" runtime] ## ["._jvm" statement] ] ## [js] ## (js ["._js" expression] - ## ["._js" eval] ## ["._js" runtime] ## ["._js" statement]) ## [lua] ## (lua ["._lua" expression] - ## ["._lua" eval] ## ["._lua" runtime] ## ["._lua" statement]) ## [ruby] ## (ruby ["._ruby" expression] - ## ["._ruby" eval] ## ["._ruby" runtime] ## ["._ruby" statement]) ## [python] ## (python ["._python" expression] - ## ["._python" eval] ## ["._python" runtime] ## ["._python" statement]) ## [r] ## (r ["._r" expression] - ## ["._r" eval] ## ["._r" runtime] ## ["._r" statement]) ## [scheme] ## (scheme ["._scheme" expression] - ## ["._scheme" eval] ## ["._scheme" runtime] ## ["._scheme" statement]) ## [common-lisp] ## (common-lisp ["._common-lisp" expression] - ## ["._common-lisp" eval] ## ["._common-lisp" runtime] ## ["._common-lisp" statement]) ## [php] ## (php ["._php" expression] - ## ["._php" eval] ## ["._php" runtime] ## ["._php" statement]) ]]]) (type: #export Runner (-> Synthesis (Error Any))) -(type: #export Definer (-> Ident Synthesis (Error Any))) +(type: #export Definer (-> Name Synthesis (Error Any))) (do-template [<name> <host>] [(def: #export <name> - (IO Lux) - (do io.Monad<IO> - [host <host>] - (wrap (init.compiler host))))] + (IO State) + (:: io.Monad<IO> map translation.state <host>))] [init-jvm jvm.init] ## [init-js js.init] @@ -85,55 +80,55 @@ ## [init-php php.init] ) -(def: (runner translate-runtime translate-expression eval init) - (All [a] (-> (Meta Any) (-> Synthesis (Meta a)) (-> a (Meta Any)) (IO Lux) - Runner)) +(def: (runner generate-runtime translate bundle state) + (-> (Operation Any) Phase Bundle (IO State) + Runner) (function (_ synthesis) - (|> (do macro.Monad<Meta> - [_ translate-runtime - sampleO (translate-expression synthesis)] - (eval sampleO)) - (language.with-current-module "") - (macro.run (io.run init))))) + (|> (do phase.Monad<Operation> + [_ generate-runtime + program (translate synthesis)] + (translation.evaluate! program)) + (phase.run [bundle (io.run state)])))) -(def: (definer translate-runtime translate-expression eval init translate-def) - (All [a] (-> (Meta Any) (-> Synthesis (Meta a)) (-> a (Meta Any)) (IO Lux) - (-> Text Type a Code (Meta Any)) - Definer)) - (function (_ [module-name def-name] synthesis) - (|> (do macro.Monad<Meta> - [_ translate-runtime - valueO (translate-expression synthesis) - _ (module.with-module +0 module-name - (translate-def def-name Any valueO (' {}))) - sampleO (translate-expression (code.identifier [module-name def-name]))] - (eval sampleO)) - (language.with-current-module "") - (macro.run (io.run init))))) +## (def: (definer generate-runtime translate bundle state translate-def) +## (All [a] +## (-> (Operation Any) Phase Bundle (IO State) +## (-> Text Type a Code (Meta Any)) +## Definer)) +## (function (_ [module-name def-name] synthesis) +## (|> (do macro.Monad<Meta> +## [_ generate-runtime +## valueO (translate synthesis) +## _ (module.with-module +0 module-name +## (translate-def def-name Any valueO (' {}))) +## sampleO (translate (code.identifier [module-name def-name]))] +## (eval sampleO)) +## (analysis.with-current-module "") +## (macro.run (io.run init))))) -(def: #export run-jvm (runner runtime_jvm.translate expression_jvm.translate eval_jvm.eval init-jvm)) -(def: #export def-jvm (definer runtime_jvm.translate expression_jvm.translate eval_jvm.eval init-jvm statement_jvm.translate-def)) +(def: #export run-jvm (runner runtime_jvm.translate expression_jvm.translate bundle.empty init-jvm)) +## (def: #export def-jvm (definer runtime_jvm.translate expression_jvm.translate init-jvm statement_jvm.translate-def)) -## (def: #export run-js (runner runtime_js.translate expression_js.translate eval_js.eval init-js)) -## (def: #export def-js (definer runtime_js.translate expression_js.translate eval_js.eval init-js statement_js.translate-def)) +## (def: #export run-js (runner runtime_js.translate expression_js.translate init-js)) +## (def: #export def-js (definer runtime_js.translate expression_js.translate init-js statement_js.translate-def)) -## (def: #export run-lua (runner runtime_lua.translate expression_lua.translate eval_lua.eval init-lua)) -## (def: #export def-lua (definer runtime_lua.translate expression_lua.translate eval_lua.eval init-lua statement_lua.translate-def)) +## (def: #export run-lua (runner runtime_lua.translate expression_lua.translate init-lua)) +## (def: #export def-lua (definer runtime_lua.translate expression_lua.translate init-lua statement_lua.translate-def)) -## (def: #export run-ruby (runner runtime_ruby.translate expression_ruby.translate eval_ruby.eval init-ruby)) -## (def: #export def-ruby (definer runtime_ruby.translate expression_ruby.translate eval_ruby.eval init-ruby statement_ruby.translate-def)) +## (def: #export run-ruby (runner runtime_ruby.translate expression_ruby.translate init-ruby)) +## (def: #export def-ruby (definer runtime_ruby.translate expression_ruby.translate init-ruby statement_ruby.translate-def)) -## (def: #export run-python (runner runtime_python.translate expression_python.translate eval_python.eval init-python)) -## (def: #export def-python (definer runtime_python.translate expression_python.translate eval_python.eval init-python statement_python.translate-def)) +## (def: #export run-python (runner runtime_python.translate expression_python.translate init-python)) +## (def: #export def-python (definer runtime_python.translate expression_python.translate init-python statement_python.translate-def)) -## (def: #export run-r (runner runtime_r.translate expression_r.translate eval_r.eval init-r)) -## (def: #export def-r (definer runtime_r.translate expression_r.translate eval_r.eval init-r statement_r.translate-def)) +## (def: #export run-r (runner runtime_r.translate expression_r.translate init-r)) +## (def: #export def-r (definer runtime_r.translate expression_r.translate init-r statement_r.translate-def)) -## (def: #export run-scheme (runner runtime_scheme.translate expression_scheme.translate eval_scheme.eval init-scheme)) -## (def: #export def-scheme (definer runtime_scheme.translate expression_scheme.translate eval_scheme.eval init-scheme statement_scheme.translate-def)) +## (def: #export run-scheme (runner runtime_scheme.translate expression_scheme.translate init-scheme)) +## (def: #export def-scheme (definer runtime_scheme.translate expression_scheme.translate init-scheme statement_scheme.translate-def)) -## (def: #export run-common-lisp (runner runtime_common-lisp.translate expression_common-lisp.translate eval_common-lisp.eval init-common-lisp)) -## (def: #export def-common-lisp (definer runtime_common-lisp.translate expression_common-lisp.translate eval_common-lisp.eval init-common-lisp statement_common-lisp.translate-def)) +## (def: #export run-common-lisp (runner runtime_common-lisp.translate expression_common-lisp.translate init-common-lisp)) +## (def: #export def-common-lisp (definer runtime_common-lisp.translate expression_common-lisp.translate init-common-lisp statement_common-lisp.translate-def)) -## (def: #export run-php (runner runtime_php.translate expression_php.translate eval_php.eval init-php)) -## (def: #export def-php (definer runtime_php.translate expression_php.translate eval_php.eval init-php statement_php.translate-def)) +## (def: #export run-php (runner runtime_php.translate expression_php.translate init-php)) +## (def: #export def-php (definer runtime_php.translate expression_php.translate init-php statement_php.translate-def)) diff --git a/new-luxc/test/test/luxc/lang/translation/function.lux b/new-luxc/test/test/luxc/lang/translation/function.lux index 9eb25d380..981dbb889 100644 --- a/new-luxc/test/test/luxc/lang/translation/function.lux +++ b/new-luxc/test/test/luxc/lang/translation/function.lux @@ -1,41 +1,55 @@ (.module: - lux - (lux [io #+ IO] - (control [monad #+ do] - pipe) - (data [product] - [maybe] - ["e" error] - text/format - (coll ["a" array] - [list "list/" Functor<List>])) - ["r" math/random "r/" Monad<Random>] - [macro] - (macro [code]) - [host] - test) - (luxc [lang] - (lang ["ls" synthesis])) - (test/luxc common)) - -(def: arity-limit Nat +10) + [lux #* + [control + [monad (#+ do)] + pipe] + [data + ["." maybe] + ["." error (#+ Error)] + [collection + ["." list ("list/." Functor<List>)]]] + [math + ["r" random ("r/." Monad<Random>)]] + [compiler + [default + ["." reference] + [phase + [analysis (#+ Arity)] + ["." synthesis (#+ Synthesis)]]]] + test] + [test + [luxc + ["." common (#+ Runner)]]]) + +(def: max-arity Nat 10) (def: arity - (r.Random ls.Arity) - (|> r.nat (r/map (|>> (n/% arity-limit) (n/max +1))))) + (r.Random Arity) + (|> r.nat (r/map (|>> (n/% max-arity) (n/max 1))))) (def: gen-function - (r.Random [ls.Arity Nat ls.Synthesis]) + (r.Random [Arity Nat Synthesis]) (do r.Monad<Random> [arity arity - arg (|> r.nat (:: @ map (n/% arity))) - #let [functionS (` ("lux function" (~ (code.nat arity)) [] - ((~ (code.int (nat-to-int (n/inc arg)))))))]] - (wrap [arity arg functionS]))) + arg (|> r.nat (:: @ map (n/% arity)))] + (wrap [arity arg + (synthesis.function/abstraction + {#synthesis.environment (list) + #synthesis.arity arity + #synthesis.body (synthesis.variable/local arg)})]))) (def: upper-alpha-ascii (r.Random Nat) - (|> r.nat (:: r.Functor<Random> map (|>> (n/% +26) (n/+ +65))))) + (|> r.nat (:: r.Functor<Random> map (|>> (n/% 26) (n/+ 65))))) + +(def: #export (check reference) + (-> Frac (Error Any) Bit) + (|>> (case> (#error.Success valueT) + (|> valueT (:coerce Frac) (f/= reference)) + + (#error.Error error) + (exec (log! error) + #0)))) (def: (function-spec run) (-> Runner Test) @@ -44,85 +58,74 @@ cut-off (|> r.nat (:: @ map (n/% arity))) args (r.list arity r.frac) #let [arg-value (maybe.assume (list.nth arg args)) - argsS (list/map code.frac args) - last-arg (n/dec arity) - cut-off (|> cut-off (n/min (n/dec last-arg)))]] + argsS (list/map (|>> synthesis.f64) args) + last-arg (dec arity) + cut-off (|> cut-off (n/min (dec last-arg)))]] ($_ seq (test "Can read arguments." - (|> (run (` ("lux call" (~ functionS) (~+ argsS)))) - (case> (#e.Success valueT) - (f/= arg-value (:coerce Frac valueT)) - - (#e.Error error) - (exec (log! error) - #0)))) + (|> (run (synthesis.function/apply [functionS argsS])) + (check arg-value))) (test "Can partially apply functions." - (or (n/= +1 arity) - (let [partial-arity (n/inc cut-off) + (or (n/= 1 arity) + (let [partial-arity (inc cut-off) preS (list.take partial-arity argsS) postS (list.drop partial-arity argsS)] - (|> (run (` ("lux call" - ("lux call" (~ functionS) (~+ preS)) - (~+ postS)))) - (case> (#e.Success valueT) - (f/= arg-value (:coerce Frac valueT)) - - (#e.Error error) - (exec (log! error) - #0)))))) + (|> (run (synthesis.function/apply {#synthesis.function (synthesis.function/apply {#synthesis.function functionS + #synthesis.arguments preS}) + #synthesis.arguments postS})) + (check arg-value))))) (test "Can read environment." - (or (n/= +1 arity) - (let [env (|> (list.n/range +0 cut-off) - (list/map (|>> n/inc nat-to-int))) - super-arity (n/inc cut-off) - arg-var (if (n/<= cut-off arg) - (|> arg n/inc nat-to-int (i/* -1)) - (|> arg n/inc (n/- super-arity) nat-to-int)) - sub-arity (|> arity (n/- super-arity)) - functionS (` ("lux function" (~ (code.nat super-arity)) [] - ("lux function" (~ (code.nat sub-arity)) [(~+ (list/map code.int env))] - ((~ (code.int arg-var))))))] - (|> (run (` ("lux call" (~ functionS) (~+ argsS)))) - (case> (#e.Success valueT) - (f/= arg-value (:coerce Frac valueT)) - - (#e.Error error) - (exec (log! error) - #0)))))) + (or (n/= 1 arity) + (let [environment (|> (list.n/range 0 cut-off) + (list/map (|>> #reference.Local))) + arity::super (inc cut-off) + argument (if (n/<= cut-off arg) + (synthesis.variable/foreign arg) + (synthesis.variable/local (n/- (dec arity::super) arg))) + arity::sub (|> arity (n/- arity::super)) + functionS (synthesis.function/abstraction + {#synthesis.environment (list) + #synthesis.arity arity::super + #synthesis.body (synthesis.function/abstraction + {#synthesis.environment environment + #synthesis.arity arity::sub + #synthesis.body argument})})] + (|> (run (synthesis.function/apply [functionS argsS])) + (check arg-value))))) ))) (context: "[JVM] Function." - (<| (times +100) - (function-spec run-jvm))) + (<| (times 100) + (function-spec common.run-jvm))) ## (context: "[JS] Function." -## (<| (times +100) -## (function-spec run-js))) +## (<| (times 100) +## (function-spec common.run-js))) ## (context: "[Lua] Function." -## (<| (times +100) -## (function-spec run-lua))) +## (<| (times 100) +## (function-spec common.run-lua))) ## (context: "[Ruby] Function." -## (<| (times +100) -## (function-spec run-ruby))) +## (<| (times 100) +## (function-spec common.run-ruby))) ## (context: "[Python] Function." -## (<| (times +100) -## (function-spec run-python))) +## (<| (times 100) +## (function-spec common.run-python))) ## (context: "[R] Function." -## (<| (times +100) -## (function-spec run-r))) +## (<| (times 100) +## (function-spec common.run-r))) ## (context: "[Scheme] Function." -## (<| (times +100) -## (function-spec run-scheme))) +## (<| (times 100) +## (function-spec common.run-scheme))) ## (context: "[Common Lisp] Function." -## (<| (times +100) -## (function-spec run-common-lisp))) +## (<| (times 100) +## (function-spec common.run-common-lisp))) ## (context: "[PHP] Function." -## (<| (times +100) -## (function-spec run-php))) +## (<| (times 100) +## (function-spec common.run-php))) diff --git a/new-luxc/test/test/luxc/lang/translation/primitive.lux b/new-luxc/test/test/luxc/lang/translation/primitive.lux index f4ff98287..12292e08c 100644 --- a/new-luxc/test/test/luxc/lang/translation/primitive.lux +++ b/new-luxc/test/test/luxc/lang/translation/primitive.lux @@ -5,8 +5,8 @@ pipe] [data ["." error] - [bit ("bit/" Equivalence<Bit>)] - [text ("text/" Equivalence<Text>) + [bit ("bit/." Equivalence<Bit>)] + [text ("text/." Equivalence<Text>) format]] [math ["r" random]] @@ -23,11 +23,9 @@ (-> Runner Test) (do r.Monad<Random> [|bit| r.bit - |nat| r.nat - |int| r.int - |rev| r.rev - |frac| r.frac - |text| (r.ascii +5)] + |i64| r.i64 + |f64| r.frac + |text| (r.ascii 5)] (`` ($_ seq (~~ (do-template [<desc> <type> <synthesis> <sample> <test>] [(test (format "Can translate " <desc> ".") @@ -36,47 +34,46 @@ (<test> <sample> (:coerce <type> valueT)) (#error.Error error) - (exec (log! error) - #0))))] + false)))] ["bit" Bit synthesis.bit |bit| bit/=] - ["int" Int synthesis.i64 |int| i/=] - ["frac" Frac synthesis.f64 |frac| f/=] + ["int" Int synthesis.i64 |i64| i/=] + ["frac" Frac synthesis.f64 |f64| f/=] ["text" Text synthesis.text |text| text/=])) )))) (context: "[JVM] Primitives." - (<| (times +100) + (<| (times 100) (spec run-jvm))) ## (context: "[JS] Primitives." -## (<| (times +100) +## (<| (times 100) ## (spec run-js))) ## (context: "[Lua] Primitives." -## (<| (times +100) +## (<| (times 100) ## (spec run-lua))) ## (context: "[Ruby] Primitives." -## (<| (times +100) +## (<| (times 100) ## (spec run-ruby))) ## (context: "[Python] Primitives." -## (<| (times +100) +## (<| (times 100) ## (spec run-python))) ## (context: "[R] Primitives." -## (<| (times +100) +## (<| (times 100) ## (spec run-r))) ## (context: "[Scheme] Primitives." -## (<| (times +100) +## (<| (times 100) ## (spec run-scheme))) ## (context: "[Common Lisp] Primitives." -## (<| (times +100) +## (<| (times 100) ## (spec run-common-lisp))) ## (context: "[PHP] Primitives." -## (<| (times +100) +## (<| (times 100) ## (spec run-php))) diff --git a/new-luxc/test/test/luxc/lang/translation/structure.lux b/new-luxc/test/test/luxc/lang/translation/structure.lux index 3251844b7..cd1b88c9d 100644 --- a/new-luxc/test/test/luxc/lang/translation/structure.lux +++ b/new-luxc/test/test/luxc/lang/translation/structure.lux @@ -1,73 +1,81 @@ (.module: - lux - (lux [io #+ IO] - (control [monad #+ do] - pipe) - (data ["e" error] - [maybe] - [bit "bit/" Eq<Bit>] - [text "text/" Eq<Text>] - text/format - (coll [array] - [list "list/" Functor<List>])) - ["r" math/random "r/" Monad<Random>] - [macro] - (macro [code]) - [host] - test) - (luxc [lang] - (lang [".L" host] - [synthesis #+ Synthesis])) - (test/luxc common)) - -(host.import: java/lang/Integer) + [lux #* + [control + [monad (#+ do)] + pipe] + [data + ["." error] + ["." maybe] + [text ("text/." Equivalence<Text>) + format] + [collection + ["." array] + ["." list ("list/." Functor<List>)]]] + [math + ["r" random]] + ["." host (#+ import:)] + [compiler + [default + [phase + ["." analysis] + ["." synthesis]]]] + test] + [test + [luxc + common]]) + +(import: java/lang/Integer) (def: (tuples-spec run) (-> Runner Test) (do r.Monad<Random> - [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) - tuple-in (r.list size r.int)] + [size (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) + tuple-in (r.list size r.i64)] (test "Can translate tuple." - (|> (run (code.tuple (list/map code.int tuple-in))) - (case> (#e.Success tuple-out) + (|> (run (synthesis.tuple (list/map (|>> synthesis.i64) tuple-in))) + (case> (#error.Success tuple-out) (let [tuple-out (:coerce (Array Any) tuple-out)] (and (n/= size (array.size tuple-out)) (list.every? (function (_ [left right]) (i/= left (:coerce Int right))) (list.zip2 tuple-in (array.to-list tuple-out))))) - (#e.Error error) + (#error.Error error) (exec (log! error) #0)))))) (def: (variants-spec run) (-> Runner Test) (do r.Monad<Random> - [num-tags (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + [num-tags (|> r.nat (:: @ map (|>> (n/% 10) (n/max 2)))) tag-in (|> r.nat (:: @ map (n/% num-tags))) - #let [last?-in (n/= (n/dec num-tags) tag-in)] - value-in r.int] + #let [last?-in (|> num-tags dec (n/= tag-in))] + value-in r.i64] (test "Can translate variant." - (|> (run (` ((~ (code.nat tag-in)) (~ (code.bit last?-in)) (~ (code.int value-in))))) - (case> (#e.Success valueT) + (|> (run (synthesis.variant {#analysis.lefts (if last?-in + (dec tag-in) + tag-in) + #analysis.right? last?-in + #analysis.value (synthesis.i64 value-in)})) + (case> (#error.Success valueT) (let [valueT (:coerce (Array Any) valueT)] - (and (n/= +3 (array.size valueT)) - (let [tag-out (:coerce Integer (maybe.assume (array.read +0 valueT))) - last?-out (array.read +1 valueT) - value-out (:coerce Any (maybe.assume (array.read +2 valueT))) - same-tag? (n/= tag-in (|> tag-out host.int-to-long (:coerce Nat))) + (and (n/= 3 (array.size valueT)) + (let [tag-out (:coerce Integer (maybe.assume (array.read 0 valueT))) + last?-out (array.read 1 valueT) + value-out (:coerce Any (maybe.assume (array.read 2 valueT))) + same-tag? (|> tag-out host.int-to-long (:coerce Nat) (n/= tag-in)) same-flag? (case last?-out (#.Some last?-out') (and last?-in (text/= "" (:coerce Text last?-out'))) #.None (not last?-in)) - same-value? (i/= value-in (:coerce Int value-out))] + same-value? (|> value-out (:coerce Int) (i/= value-in))] (and same-tag? same-flag? same-value?)))) - (#e.Error error) + (#error.Error error) (exec (log! error) #0)))))) @@ -78,37 +86,37 @@ (variants-spec run))) (context: "[JVM] Structures." - (<| (times +100) + (<| (times 100) (structure-spec run-jvm))) ## (context: "[JS] Structures." -## (<| (times +100) +## (<| (times 100) ## (structure-spec run-js))) ## (context: "[Lua] Structures." -## (<| (times +100) +## (<| (times 100) ## (structure-spec run-lua))) ## (context: "[Ruby] Structures." -## (<| (times +100) +## (<| (times 100) ## (structure-spec run-ruby))) ## (context: "[Python] Structures." -## (<| (times +100) +## (<| (times 100) ## (structure-spec run-python))) ## (context: "[R] Structures." -## (<| (times +100) +## (<| (times 100) ## (structure-spec run-r))) ## (context: "[Scheme] Structures." -## (<| (times +100) +## (<| (times 100) ## (structure-spec run-scheme))) ## (context: "[Common Lisp] Structures." -## (<| (times +100) +## (<| (times 100) ## (structure-spec run-common-lisp))) ## (context: "[PHP] Structures." -## (<| (times +100) +## (<| (times 100) ## (structure-spec run-php))) |